fix(anatomy): V1-2.2 refuse zones without a usable interior

A polygon or path zone or trigger must fill a disc of 4 CSS px on the
320 x 568 preview under the layer's nonzero rule, stroke left out:
conservative widest-disc search on the flattened outline, caps and a
per-sheet budget, closed codes interior_too_small and
marker_interior_too_small. Browser probe on six projects.
This commit is contained in:
bchanot committed 2026-11-01 12:19:08 +01:00
1 parent de2dfb392e
commit 8dd2d78d38
18 files changed
+1852 -38

No files matched your search

+1
View File
@@ -3,6 +3,7 @@ crates/core/tests/oracles/
crates/core/tests/conformance/
crates/core/tests/fixtures/
apps/app/tests/fixtures/goldens/
apps/app/e2e/fixtures/interior-probe.json
packages/core-wasm/types/
packages/core-wasm/pkg/
packages/core-wasm/pkg-proofs/
+219
View File
@@ -0,0 +1,219 @@
{
"generatedBy": "crates/core/tests/interior_probe.rs",
"frame": {
"width": 286,
"height": 310
},
"cases": [
{
"name": "square-6",
"accepted": true,
"codes": [],
"widest": {
"x": 43.0,
"y": 43.0,
"r": 3.0
},
"svg": "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" viewBox=\"0 0 286 310\"><g><path d=\"M0 0h1\"/></g><g data-layer=\"annotations\" data-view-id=\"main\"><polygon points=\"40,40 46,40 46,46 40,46\" fill=\"#888888\" stroke=\"#888888\" fill-opacity=\"0.3\" stroke-width=\"2\" pointer-events=\"all\" style=\"cursor:pointer\" data-anno-id=\"shape\" data-anno-kind=\"zone\" data-anno-lateral=\"unpaired\" data-anno-name-fr=\"Jarret\" data-anno-name-en=\"Jarret\"><title>Jarret / Jarret</title></polygon></g></svg>"
},
{
"name": "flat-triangle",
"accepted": true,
"codes": [],
"widest": {
"x": 70.0,
"y": 42.287,
"r": 2.287
},
"svg": "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" viewBox=\"0 0 286 310\"><g><path d=\"M0 0h1\"/></g><g data-layer=\"annotations\" data-view-id=\"main\"><polygon points=\"40,40 100,40 70,44.6\" fill=\"#888888\" stroke=\"#888888\" fill-opacity=\"0.3\" stroke-width=\"2\" pointer-events=\"all\" style=\"cursor:pointer\" data-anno-id=\"shape\" data-anno-kind=\"zone\" data-anno-lateral=\"unpaired\" data-anno-name-fr=\"Jarret\" data-anno-name-en=\"Jarret\"><title>Jarret / Jarret</title></polygon></g></svg>"
},
{
"name": "arc-disc-6",
"accepted": true,
"codes": [],
"widest": {
"x": 43.0,
"y": 50.0,
"r": 2.998
},
"svg": "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" viewBox=\"0 0 286 310\"><g><path d=\"M0 0h1\"/></g><g data-layer=\"annotations\" data-view-id=\"main\"><path d=\"M40 50a3 3 0 1 0 6 0a3 3 0 1 0 -6 0Z\" fill=\"#888888\" stroke=\"#888888\" fill-opacity=\"0.3\" stroke-width=\"2\" pointer-events=\"all\" style=\"cursor:pointer\" data-anno-id=\"shape\" data-anno-kind=\"zone\" data-anno-lateral=\"unpaired\" data-anno-name-fr=\"Jarret\" data-anno-name-en=\"Jarret\"><title>Jarret / Jarret</title></path></g></svg>"
},
{
"name": "cubic-lens",
"accepted": true,
"codes": [],
"widest": {
"x": 59.999,
"y": 50.0,
"r": 4.498
},
"svg": "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" viewBox=\"0 0 286 310\"><g><path d=\"M0 0h1\"/></g><g data-layer=\"annotations\" data-view-id=\"main\"><path d=\"M40 50C50 44 70 44 80 50C70 56 50 56 40 50Z\" fill=\"#888888\" stroke=\"#888888\" fill-opacity=\"0.3\" stroke-width=\"2\" pointer-events=\"all\" style=\"cursor:pointer\" data-anno-id=\"shape\" data-anno-kind=\"zone\" data-anno-lateral=\"unpaired\" data-anno-name-fr=\"Jarret\" data-anno-name-en=\"Jarret\"><title>Jarret / Jarret</title></path></g></svg>"
},
{
"name": "ell-3.6",
"accepted": true,
"codes": [],
"widest": {
"x": 42.109,
"y": 42.109,
"r": 2.109
},
"svg": "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" viewBox=\"0 0 286 310\"><g><path d=\"M0 0h1\"/></g><g data-layer=\"annotations\" data-view-id=\"main\"><polygon points=\"40,40 80,40 80,43.6 43.6,43.6 43.6,80 40,80\" fill=\"#888888\" stroke=\"#888888\" fill-opacity=\"0.3\" stroke-width=\"2\" pointer-events=\"all\" style=\"cursor:pointer\" data-anno-id=\"shape\" data-anno-kind=\"zone\" data-anno-lateral=\"unpaired\" data-anno-name-fr=\"Jarret\" data-anno-name-en=\"Jarret\"><title>Jarret / Jarret</title></polygon></g></svg>"
},
{
"name": "pentagram-evenodd-root",
"accepted": true,
"codes": [],
"widest": {
"x": 59.999,
"y": 60.0,
"r": 3.09
},
"svg": "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" viewBox=\"0 0 286 310\"><g fill-rule=\"evenodd\"><path d=\"M0 0h1\"/></g><g data-layer=\"annotations\" data-view-id=\"main\"><polygon points=\"60,50 65.87785252292473,68.09016994374947 50.489434837048464,56.90983005625053 69.51056516295154,56.90983005625053 54.12214747707527,68.09016994374947\" fill=\"#888888\" stroke=\"#888888\" fill-opacity=\"0.3\" stroke-width=\"2\" pointer-events=\"all\" style=\"cursor:pointer\" data-anno-id=\"shape\" data-anno-kind=\"zone\" data-anno-lateral=\"unpaired\" data-anno-name-fr=\"Jarret\" data-anno-name-en=\"Jarret\"><title>Jarret / Jarret</title></polygon></g></svg>"
},
{
"name": "forth-and-back",
"accepted": false,
"codes": [
"annotation.geometry.interior_too_small"
],
"widest": null,
"svg": "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" viewBox=\"0 0 286 310\"><g><path d=\"M0 0h1\"/></g><g data-layer=\"annotations\" data-view-id=\"main\"><path d=\"M40 40L90 90L40 40\" fill=\"#888888\" stroke=\"#888888\" fill-opacity=\"0.3\" stroke-width=\"2\" pointer-events=\"all\" style=\"cursor:pointer\" data-anno-id=\"shape\" data-anno-kind=\"zone\" data-anno-lateral=\"unpaired\" data-anno-name-fr=\"Jarret\" data-anno-name-en=\"Jarret\"><title>Jarret / Jarret</title></path></g></svg>"
},
{
"name": "square-twice-opposite",
"accepted": false,
"codes": [
"annotation.geometry.interior_too_small"
],
"widest": null,
"svg": "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" viewBox=\"0 0 286 310\"><g><path d=\"M0 0h1\"/></g><g data-layer=\"annotations\" data-view-id=\"main\"><path d=\"M40 40h40v40h-40zM40 40v40h40v-40z\" fill=\"#888888\" stroke=\"#888888\" fill-opacity=\"0.3\" stroke-width=\"2\" pointer-events=\"all\" style=\"cursor:pointer\" data-anno-id=\"shape\" data-anno-kind=\"zone\" data-anno-lateral=\"unpaired\" data-anno-name-fr=\"Jarret\" data-anno-name-en=\"Jarret\"><title>Jarret / Jarret</title></path></g></svg>"
},
{
"name": "diagonal-sliver",
"accepted": false,
"codes": [
"annotation.geometry.interior_too_small"
],
"widest": {
"x": 89.507,
"y": 88.809,
"r": 0.493
},
"svg": "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" viewBox=\"0 0 286 310\"><g><path d=\"M0 0h1\"/></g><g data-layer=\"annotations\" data-view-id=\"main\"><polygon points=\"40,40 90,90 90,88.6\" fill=\"#888888\" stroke=\"#888888\" fill-opacity=\"0.3\" stroke-width=\"2\" pointer-events=\"all\" style=\"cursor:pointer\" data-anno-id=\"shape\" data-anno-kind=\"zone\" data-anno-lateral=\"unpaired\" data-anno-name-fr=\"Jarret\" data-anno-name-en=\"Jarret\"><title>Jarret / Jarret</title></polygon></g></svg>"
},
{
"name": "cubic-there-and-back",
"accepted": false,
"codes": [
"annotation.geometry.interior_too_small"
],
"widest": null,
"svg": "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" viewBox=\"0 0 286 310\"><g><path d=\"M0 0h1\"/></g><g data-layer=\"annotations\" data-view-id=\"main\"><path d=\"M40 80C50 40 80 40 90 80C80 40 50 40 40 80Z\" fill=\"#888888\" stroke=\"#888888\" fill-opacity=\"0.3\" stroke-width=\"2\" pointer-events=\"all\" style=\"cursor:pointer\" data-anno-id=\"shape\" data-anno-kind=\"zone\" data-anno-lateral=\"unpaired\" data-anno-name-fr=\"Jarret\" data-anno-name-en=\"Jarret\"><title>Jarret / Jarret</title></path></g></svg>"
},
{
"name": "arc-there-and-back",
"accepted": false,
"codes": [
"annotation.geometry.interior_too_small"
],
"widest": null,
"svg": "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" viewBox=\"0 0 286 310\"><g><path d=\"M0 0h1\"/></g><g data-layer=\"annotations\" data-view-id=\"main\"><path d=\"M40 80A25 25 0 0 1 90 80A25 25 0 0 0 40 80Z\" fill=\"#888888\" stroke=\"#888888\" fill-opacity=\"0.3\" stroke-width=\"2\" pointer-events=\"all\" style=\"cursor:pointer\" data-anno-id=\"shape\" data-anno-kind=\"zone\" data-anno-lateral=\"unpaired\" data-anno-name-fr=\"Jarret\" data-anno-name-en=\"Jarret\"><title>Jarret / Jarret</title></path></g></svg>"
},
{
"name": "flat-ellipse-45",
"accepted": false,
"codes": [
"annotation.geometry.interior_too_small"
],
"widest": {
"x": 65.0,
"y": 65.0,
"r": 1.0
},
"svg": "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" viewBox=\"0 0 286 310\"><g><path d=\"M0 0h1\"/></g><g data-layer=\"annotations\" data-view-id=\"main\"><path d=\"M40 40A35 1 45 0 1 90 90A35 1 45 0 1 40 40Z\" fill=\"#888888\" stroke=\"#888888\" fill-opacity=\"0.3\" stroke-width=\"2\" pointer-events=\"all\" style=\"cursor:pointer\" data-anno-id=\"shape\" data-anno-kind=\"zone\" data-anno-lateral=\"unpaired\" data-anno-name-fr=\"Jarret\" data-anno-name-en=\"Jarret\"><title>Jarret / Jarret</title></path></g></svg>"
},
{
"name": "ell-3.3",
"accepted": false,
"codes": [
"annotation.geometry.interior_too_small"
],
"widest": {
"x": 41.933,
"y": 41.933,
"r": 1.933
},
"svg": "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" viewBox=\"0 0 286 310\"><g><path d=\"M0 0h1\"/></g><g data-layer=\"annotations\" data-view-id=\"main\"><polygon points=\"40,40 80,40 80,43.3 43.3,43.3 43.3,80 40,80\" fill=\"#888888\" stroke=\"#888888\" fill-opacity=\"0.3\" stroke-width=\"2\" pointer-events=\"all\" style=\"cursor:pointer\" data-anno-id=\"shape\" data-anno-kind=\"zone\" data-anno-lateral=\"unpaired\" data-anno-name-fr=\"Jarret\" data-anno-name-en=\"Jarret\"><title>Jarret / Jarret</title></polygon></g></svg>"
},
{
"name": "triangle-6.6",
"accepted": false,
"codes": [
"annotation.geometry.interior_too_small"
],
"widest": {
"x": 43.3,
"y": 43.811,
"r": 1.905
},
"svg": "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" viewBox=\"0 0 286 310\"><g><path d=\"M0 0h1\"/></g><g data-layer=\"annotations\" data-view-id=\"main\"><polygon points=\"40,45.716 46.6,45.716 43.3,40\" fill=\"#888888\" stroke=\"#888888\" fill-opacity=\"0.3\" stroke-width=\"2\" pointer-events=\"all\" style=\"cursor:pointer\" data-anno-id=\"shape\" data-anno-kind=\"zone\" data-anno-lateral=\"unpaired\" data-anno-name-fr=\"Jarret\" data-anno-name-en=\"Jarret\"><title>Jarret / Jarret</title></polygon></g></svg>"
}
],
"equine": [
{
"id": "caudal",
"view": "main",
"widest": {
"x": 1692.151,
"y": 554.007,
"r": 17.95
}
},
{
"id": "sacral",
"view": "main",
"widest": {
"x": 1470.781,
"y": 505.112,
"r": 40.963
}
},
{
"id": "lumbar",
"view": "main",
"widest": {
"x": 1341.641,
"y": 510.702,
"r": 51.297
}
},
{
"id": "thoracic",
"view": "main",
"widest": {
"x": 872.953,
"y": 484.677,
"r": 41.579
}
},
{
"id": "cervical",
"view": "main",
"widest": {
"x": 521.605,
"y": 279.763,
"r": 44.126
}
},
{
"id": "head-trigger",
"view": "main",
"widest": {
"x": 341.041,
"y": 303.749,
"r": 105.59
}
}
]
}
+12
View File
@@ -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>Interior harness</title>
</head>
<body style="margin: 0">
<div id="root"></div>
<script type="module" src="./interior.ts"></script>
</body>
</html>
+33
View File
@@ -0,0 +1,33 @@
/**
* Test page for the interior rule in a real browser (e2e/ui/interior-clicks.spec.ts): the
* canvas the core composes for one probe case (e2e/fixtures/interior-probe.json, generated by
* crates/core/tests/interior_probe.rs) in the phone preview's 286 × 310 box, inserted as the
* editor inserts it (DOMParser, importNode), every click on a marker recorded. Served by the
* Vite dev server only (`/e2e/harness/interior.html?case=`); the build never ships it.
*/
import probe from '../fixtures/interior-probe.json'
const name = new URLSearchParams(location.search).get('case')
const found = probe.cases.find((c) => c.name === name)
if (!found) throw new Error(`no probe case ${String(name)}`)
const root = document.getElementById('root') as HTMLElement
const clicks = document.createElement('output')
clicks.dataset.testid = 'clicks'
clicks.style.cssText = 'display:block;height:24px;overflow:hidden'
const box = document.createElement('div')
box.dataset.testid = 'preview'
box.style.cssText = `width:${probe.frame.width}px;height:${probe.frame.height}px`
const parsed = new DOMParser().parseFromString(found.svg, 'image/svg+xml')
const svg = document.importNode(
parsed.documentElement,
true,
) as unknown as SVGSVGElement
svg.style.cssText = 'display:block;width:100%;height:100%'
box.append(svg)
root.append(clicks, box)
box.addEventListener('click', (event) => {
const marker = (event.target as Element).closest('[data-anno-id]')
const id = marker?.getAttribute('data-anno-id')
if (id) clicks.textContent = `${clicks.textContent ?? ''} ${id}`.trim()
})
+3 -2
View File
@@ -41,13 +41,14 @@ export const PROJECTS: Project[] = [
]
/**
* The canvas click proof (V1-2.2, e2e/ui/canvas-clicks.spec.ts) also runs on Firefox and
* The canvas click proofs (V1-2.2, e2e/ui/canvas-clicks.spec.ts and interior-clicks.spec.ts)
* also run on Firefox and
* WebKit, desktop, and on the WebKit phone, when the pinned engine is installed, and on a
* 320 px Chromium phone
* (`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$/
const CANVAS_CLICKS = /(canvas|interior)-clicks\.spec\.ts$/
function installed(name: string, executable: string): boolean {
const present = existsSync(executable)
+295
View File
@@ -0,0 +1,295 @@
import { expect, test } from '../support/browser'
import type { Page } from '@playwright/test'
import probe from '../fixtures/interior-probe.json'
// Owner brief « V1-2.2 : fermeture du dernier MEDIUM » (2026-11-01): a zone or a trigger drawn
// as a polygon or a path must fill a disc of 4 CSS px on the phone preview, its stroke left
// out. The core's verdict (e2e/fixtures/interior-probe.json, crates/core/tests/interior_probe.rs)
// against the browser's own hit test, in the preview's 286 × 310 box (one unit per CSS px):
// an accepted shape takes real presses in the disc the core found and its fill alone holds a
// 4 px disc; a refused one fills none. Then the equine draft's zones, in the editor canvas.
// Run on Chromium, Firefox and WebKit when installed.
type Point = { x: number; y: number }
type Disc = { x: number; y: number; r: number }
/** The threshold: a disc of 4 CSS px across. */
const MIN_RADIUS_PX = 2
/** The browser's mask is sampled every quarter pixel: its radius is within that of the fill. */
const MASK_STEP_PX = 0.25
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)
}
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: boolean) {
const before = (await recorded(page)).length
await press(page, at, touch)
await page.waitForTimeout(50)
return (await recorded(page)).slice(before)
}
test.describe('interior clicks', () => {
for (const c of probe.cases) {
test(`${c.accepted ? 'accepted' : 'refused'}: ${c.name}`, async ({
page,
}, info) => {
await page.goto(`/e2e/harness/interior.html?case=${c.name}`)
await expect(page.locator('[data-anno-id="shape"]')).toBeAttached()
const browser = await page.evaluate(widestFill, MASK_STEP_PX)
if (c.widest) {
// The core never claims more than the browser fills (it may claim less: its disc
// crosses no edge, where a nonzero fill may run on past one).
expect(browser.r, JSON.stringify(browser)).toBeGreaterThan(
c.widest.r - 0.5,
)
}
if (!c.accepted) {
expect(browser.r, JSON.stringify(browser)).toBeLessThan(MIN_RADIUS_PX)
return
}
if (!c.widest) throw new Error(`${c.name} accepted without a disc`)
expect(browser.r).toBeGreaterThanOrEqual(MIN_RADIUS_PX)
const disc = c.widest
for (const fillOnly of [true, false]) {
const ring = await page.evaluate(ringHits, { disc, fillOnly })
expect(ring, `fillOnly ${String(fillOnly)}`).toEqual({
missed: [],
covered: 0,
})
}
const centre = await page.evaluate(toScreen, { x: disc.x, y: disc.y })
const touch = info.project.use.hasTouch === true
expect(await clickRecords(page, centre, touch)).toEqual(['shape'])
})
}
test('every equine zone holds the disc the core found and takes a real press', async ({
page,
}, info) => {
await page.goto('/e2e/harness/canvas.html')
await expect(
page.locator('[data-testid="anatomy-canvas"] [data-anno-id="caudal"]'),
).toBeAttached()
const touch = info.project.use.hasTouch === true
for (const zone of probe.equine) {
if (!zone.widest) throw new Error(`${zone.id} without a disc`)
const disc = zone.widest
// A point painted over the zone takes its taps (« the visible wins »): the samples under
// a visible disc are left out, at most a quarter of them.
const { missed, covered } = await page.evaluate(ringHits, {
disc,
fillOnly: false,
id: zone.id,
clearOfDiscs: true,
})
expect(missed, zone.id).toEqual([])
expect(covered, zone.id).toBeLessThanOrEqual(8)
// Chromium's touch adjustment gives a point the taps up to about 10 px around its disc
// (measured 2026-11-01): the real press goes where the zone's fill lies farthest from
// every disc, inside its edges.
const at = await page.evaluate(clearestFill, { id: zone.id, disc })
expect(await clickRecords(page, at, touch), zone.id).toEqual([zone.id])
}
})
})
/**
* In the page: the point of the shape's fill, on a half CSS px grid, its own on the hit test and
* inside its edges by 2 px or 60 % of the core's disc radius if less (the caudal zone's disc is
* 4.95 px across at 320), farthest from every visible disc.
*/
function clearestFill(args: { id: string; disc: Disc }): Point {
const { id, disc } = args
const svg = document.querySelector(
'[data-testid="anatomy-canvas"] svg',
) as SVGSVGElement
const ctm = svg.getScreenCTM()
if (!ctm) throw new Error('no CTM')
const shape = svg.querySelector(
`[data-anno-id="${id}"]`,
) as SVGGeometryElement
const twins = (
Array.from(
svg.querySelectorAll('circle[pointer-events="visiblePainted"]'),
) as SVGCircleElement[]
).map((t) => ({
centre: new DOMPoint(
t.cx.baseVal.value,
t.cy.baseVal.value,
).matrixTransform(ctm),
r: t.r.baseVal.value * ctm.a,
}))
const inverse = ctm.inverse()
const filled = (x: number, y: number) =>
shape.isPointInFill(new DOMPoint(x, y).matrixTransform(inverse))
const margin = Math.min(2, 0.6 * disc.r * ctm.a)
const box = shape.getBoundingClientRect()
let best = { x: 0, y: 0, d: -1 }
for (let x = Math.ceil(box.left); x <= box.right; x += 0.5) {
for (let y = Math.ceil(box.top); y <= box.bottom; y += 0.5) {
const steps = [-margin, 0, margin]
const inside = steps.every((dx) =>
steps.every((dy) => filled(x + dx, y + dy)),
)
if (!inside) continue
const hit = document.elementFromPoint(x, y)?.closest('[data-anno-id]')
if (hit?.getAttribute('data-anno-id') !== id) continue
const d = Math.min(
...twins.map((t) => Math.hypot(x - t.centre.x, y - t.centre.y) - t.r),
)
if (d > best.d) best = { x, y, d }
}
}
if (best.d < 0) throw new Error(`${id}: no fill clear of the discs`)
return { x: best.x, y: best.y }
}
/** In the page: a point of the layer's user space on screen. */
function toScreen(at: Point): Point {
const svg = document.querySelector('svg') as SVGSVGElement
const ctm = svg.getScreenCTM()
if (!ctm) throw new Error('no CTM')
const p = new DOMPoint(at.x, at.y).matrixTransform(ctm)
return { x: p.x, y: p.y }
}
/**
* In the page: the browser's hit test at the disc's centre and 32 points at 90 % of its radius.
* With `fillOnly` the shape takes `pointer-events="fill"` meanwhile, its stroke out of the test;
* with `clearOfDiscs` the points within a visible disc (its stroke and half a pixel included)
* are counted apart. Answers the points that hit another element, and the points left out.
*/
function ringHits(args: {
disc: Disc
fillOnly: boolean
id?: string
clearOfDiscs?: boolean
}): { missed: string[]; covered: number } {
const { disc, fillOnly } = args
const id = args.id ?? 'shape'
const svg = document.querySelector('svg') as SVGSVGElement
const ctm = svg.getScreenCTM()
if (!ctm) throw new Error('no CTM')
const shapes = Array.from(svg.querySelectorAll(`[data-anno-id="${id}"]`))
const kept = shapes.map((s) => s.getAttribute('pointer-events'))
if (fillOnly) shapes.forEach((s) => s.setAttribute('pointer-events', 'fill'))
const reach = disc.r * 0.9
const points: Point[] = [{ x: disc.x, y: disc.y }]
for (let k = 0; k < 32; k++) {
const a = (k * 2 * Math.PI) / 32
points.push({
x: disc.x + reach * Math.cos(a),
y: disc.y + reach * Math.sin(a),
})
}
const twins = Array.from(
svg.querySelectorAll('circle[pointer-events="visiblePainted"]'),
) as SVGCircleElement[]
const underDisc = (at: Point) =>
twins.some(
(t) =>
Math.hypot(at.x - t.cx.baseVal.value, at.y - t.cy.baseVal.value) <=
t.r.baseVal.value + 0.75 + 0.5 / ctm.a,
)
const missed: string[] = []
let covered = 0
for (const at of points) {
if (args.clearOfDiscs && underDisc(at)) {
covered++
continue
}
const p = new DOMPoint(at.x, at.y).matrixTransform(ctm)
const hit = document
.elementFromPoint(p.x, p.y)
?.closest('[data-anno-id]')
?.getAttribute('data-anno-id')
if (hit !== id)
missed.push(`${at.x.toFixed(2)},${at.y.toFixed(2)}: ${String(hit)}`)
}
shapes.forEach((s, i) => {
const value = kept[i]
if (value === null || value === undefined)
s.removeAttribute('pointer-events')
else s.setAttribute('pointer-events', value)
})
return { missed, covered }
}
/**
* In the page: the widest disc of the shape's fill as the browser hits it (`pointer-events`
* `fill`, the stroke out), from a mask sampled every `step` CSS px over its box and 3 px around
* it, by an exact Euclidean distance transform (Felzenszwalb and Huttenlocher). The radius is
* the distance to the nearest sample outside the fill, less half a step.
*/
function widestFill(step: number): Disc {
const svg = document.querySelector('svg') as SVGSVGElement
const shape = svg.querySelector(
'[data-anno-id="shape"]',
) as SVGGraphicsElement
const kept = shape.getAttribute('pointer-events')
shape.setAttribute('pointer-events', 'fill')
const box = shape.getBoundingClientRect()
const x0 = box.left - 3
const y0 = box.top - 3
const w = Math.ceil((box.width + 6) / step) + 1
const h = Math.ceil((box.height + 6) / step) + 1
const far = 1e20
const grid = new Float64Array(w * h)
for (let j = 0; j < h; j++) {
for (let i = 0; i < w; i++) {
const hit = document.elementFromPoint(x0 + i * step, y0 + j * step)
grid[j * w + i] = hit === shape ? far : 0
}
}
if (kept === null) shape.removeAttribute('pointer-events')
else shape.setAttribute('pointer-events', kept)
const line = (f: Float64Array): Float64Array => {
const n = f.length
const d = new Float64Array(n)
const v = new Int32Array(n)
const z = new Float64Array(n + 1)
let k = 0
v[0] = 0
z[0] = -Infinity
z[1] = Infinity
for (let q = 1; q < n; q++) {
let s = (f[q] + q * q - (f[v[k]] + v[k] * v[k])) / (2 * q - 2 * v[k])
while (s <= z[k]) {
k--
s = (f[q] + q * q - (f[v[k]] + v[k] * v[k])) / (2 * q - 2 * v[k])
}
k++
v[k] = q
z[k] = s
z[k + 1] = Infinity
}
k = 0
for (let q = 0; q < n; q++) {
while (z[k + 1] < q) k++
d[q] = (q - v[k]) ** 2 + f[v[k]]
}
return d
}
for (let i = 0; i < w; i++) {
const column = new Float64Array(h)
for (let j = 0; j < h; j++) column[j] = grid[j * w + i]
const done = line(column)
for (let j = 0; j < h; j++) grid[j * w + i] = done[j]
}
let best = { x: 0, y: 0, r: 0 }
for (let j = 0; j < h; j++) {
const done = line(grid.subarray(j * w, (j + 1) * w).slice())
for (let i = 0; i < w; i++) {
const r = Math.sqrt(done[i]) * step - step / 2
if (r > best.r) best = { x: x0 + i * step, y: y0 + j * step, r }
}
}
return best
}
+51 -10
View File
@@ -16,7 +16,11 @@
//! about `|v| × 2⁻²⁴` and, measured against the frame, grows with the ratio of the frame's
//! farthest edge to its span. And each annotation must show at least `MIN_VISIBLE_PX` on the
//! smallest preview the product supports, measured on the shape the layer paints.
//!
//! Owner brief 2026-11-01 (the last MEDIUM, zone without interior): a polygon or a path must
//! also fill a disc of `MIN_VISIBLE_PX` on that preview (`interior`), its stroke left out.
use super::interior::{Budget, LAYER_FILL_RULE, Search, geometry_outline, widest_disc};
use super::layer::{find_view, twin_radius};
use super::path::{Bounds, number_list, path_bounds};
use super::svg::Element;
@@ -61,6 +65,9 @@ pub const DETAIL_PREVIEW_PX: (f64, f64) = (254.0, 191.0);
/// The smallest visible size of an annotation on that preview (owner decision 2026-11-01): a
/// point's visible disc, a filled shape's smaller side. The equine junctions show 4.97 px.
pub const MIN_VISIBLE_PX: f64 = 4.0;
/// How far a chord may depart from its curve, and the step below which the interior search
/// cuts no cell, on that preview: far below a device pixel, taken off the measure.
pub const INTERIOR_TOLERANCE_PX: f64 = 0.05;
impl Frame {
fn from_numbers(min_x: f64, min_y: f64, width: f64, height: f64) -> Option<Self> {
@@ -138,6 +145,12 @@ pub enum Placement {
Unreadable,
/// In frame, but smaller than `MIN_VISIBLE_PX` on the smallest preview.
TooSmall,
/// A polygon or a path in frame whose fill holds no disc of `MIN_VISIBLE_PX` on the smallest
/// preview.
InteriorTooSmall,
/// A polygon or a path the interior measure cannot afford: past
/// `interior::MAX_OUTLINE_VERTICES`, or the sheet's `interior::MAX_INTERIOR_WORK` spent.
InteriorUnmeasured,
}
/// The size an annotation shows, in frame units: what the layer paints. A point's (or a circle
@@ -190,26 +203,52 @@ fn placement_with_bounds(geometry: &Geometry, frame: &Frame) -> (Placement, Opti
}
}
/// The placement of `annotation` on its view's frame, its visible size on the smallest preview
/// included.
pub fn annotation_placement(annotation: &Annotation, frame: &Frame, main_view: bool) -> Placement {
/// The placement of `annotation` on its view's frame, its visible size and its interior on the
/// smallest preview included, the interior measured within the sheet's `budget`.
pub fn annotation_placement(
annotation: &Annotation,
frame: &Frame,
main_view: bool,
budget: &mut Budget,
) -> Placement {
let Some(geometry) = geometry_of(annotation) else {
return Placement::InFrame;
};
match placement_with_bounds(geometry, frame) {
(Placement::InFrame, Some(bounds)) => {
let shown =
visible_size(annotation, geometry, &bounds) * frame.preview_scale(main_view);
if shown >= MIN_VISIBLE_PX {
Placement::InFrame
} else {
let scale = frame.preview_scale(main_view);
if visible_size(annotation, geometry, &bounds) * scale < MIN_VISIBLE_PX {
Placement::TooSmall
} else {
interior_placement(geometry, scale, budget)
}
}
(placement, _) => placement,
}
}
/// Whether the fill of a polygon or a path holds a disc of `MIN_VISIBLE_PX` at `scale` CSS px
/// per unit; a circle's disc is its own (path data the bounds read whole always has an outline).
fn interior_placement(geometry: &Geometry, scale: f64, budget: &mut Budget) -> Placement {
let tolerance = INTERIOR_TOLERANCE_PX / scale;
let Some(outline) = geometry_outline(geometry, tolerance) else {
return Placement::InFrame;
};
if !budget.affords(&outline) {
return Placement::InteriorUnmeasured;
}
let radius = MIN_VISIBLE_PX / 2.0 / scale;
let search = Search {
floor: radius,
enough: radius,
precision: tolerance,
};
match widest_disc(&outline, LAYER_FILL_RULE, &search, budget) {
Some(disc) if disc.radius >= radius => Placement::InFrame,
_ => Placement::InteriorTooSmall,
}
}
/// What the frame check found on one view.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum FrameFault {
@@ -229,6 +268,7 @@ pub fn frame_faults<'a>(
drawing_of: impl Fn(&str) -> Option<&'a Element>,
) -> Vec<FrameFault> {
let mut faults = Vec::new();
let mut budget = Budget::default();
for (view_index, view) in document.views.iter().enumerate() {
// A repeated view id draws the first view of that id, as the composers find it.
if !find_view(document, view.id()).is_some_and(|first| std::ptr::eq(first, view)) {
@@ -242,7 +282,7 @@ pub fn frame_faults<'a>(
faults.push(FrameFault::NoFrame { view_index });
continue;
};
faults.extend(annotation_faults(document, view, &frame));
faults.extend(annotation_faults(document, view, &frame, &mut budget));
}
faults
}
@@ -251,6 +291,7 @@ fn annotation_faults(
document: &AnatomicalSheetDocument,
view: &SheetView,
frame: &Frame,
budget: &mut Budget,
) -> Vec<FrameFault> {
document
.annotations
@@ -258,7 +299,7 @@ fn annotation_faults(
.enumerate()
.filter(|(_, a)| a.view_id() == view.id())
.filter_map(|(annotation_index, annotation)| {
let placement = annotation_placement(annotation, frame, view.is_main());
let placement = annotation_placement(annotation, frame, view.is_main(), budget);
(placement != Placement::InFrame).then_some(FrameFault::Annotation {
annotation_index,
placement,
+450
View File
@@ -0,0 +1,450 @@
//! The interior a tap can reach in a filled shape (owner brief « V1-2.2 : fermeture du dernier
//! MEDIUM », 2026-11-01). A zone or a trigger drawn as a polygon or a path passes the bounds rule
//! of `frame` with a large box and still selects nothing: a path drawn forth and back fills no
//! point (winding 0), a near-flat polygon fills a sliver. The layer's shapes take taps on their
//! fill and their 2-unit stroke; the stroke never counts here.
//!
//! The measure is the widest disc the fill holds, under the fill rule the layer paints with
//! (`LAYER_FILL_RULE`: the layer writes none, the composition root carries none, so `nonzero`).
//! It is conservative. A centre counts only when the fill rule puts it inside and every edge of
//! the outline, the closing edges included, is at least the radius away: the disc then crosses
//! no edge, so every point of it has the centre's winding number. Curves and arcs are cut into
//! chords (`path::path_outline`) and the chord deviation is taken off the radius. The search is
//! the polylabel subdivision (square cells, a cell's best possible centre is its centre's
//! distance plus its half diagonal, the most promising cell cut first), at most
//! `MAX_INTERIOR_CELLS` cells: deterministic, and what it has not shown counts as absent. One
//! budget (`Budget`, edge distances) bounds the work on a whole sheet: a shape it can no longer
//! afford is refused, never accepted.
use std::cmp::Ordering;
use std::collections::BinaryHeap;
use std::f64::consts::SQRT_2;
use super::path::{Outline, path_outline};
use crate::domain::sheet::Geometry;
/// How a point is inside a fill (SVG `fill-rule`).
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum FillRule {
NonZero,
EvenOdd,
}
/// The fill rule of the layer's shapes: the SVG initial value, as no `fill-rule` reaches them.
pub const LAYER_FILL_RULE: FillRule = FillRule::NonZero;
/// The largest number of outline vertices measured: past it the shape is refused (a hand-drawn
/// zone holds tens; the equine at most 17).
pub const MAX_OUTLINE_VERTICES: usize = 4096;
/// The largest number of cells the search evaluates.
pub const MAX_INTERIOR_CELLS: usize = 4096;
/// The edge distances the measure may compute on one sheet: `2²⁵`, about 0.35 s natively
/// (measured 2026-11-01: 8 192 edges × 4 096 cells), where the equine draft takes about 10⁵.
pub const MAX_INTERIOR_WORK: usize = 1 << 25;
/// The work left to the measure on one sheet.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Budget {
pub work: usize,
}
impl Default for Budget {
fn default() -> Self {
Self {
work: MAX_INTERIOR_WORK,
}
}
}
impl Budget {
/// The cells left for an outline of `edges` edges.
fn cells(&self, edges: usize) -> usize {
MAX_INTERIOR_CELLS.min(self.work / edges.max(1))
}
/// Whether the outline can still be measured: within the vertex cap, one cell affordable.
pub fn affords(&self, outline: &Outline) -> bool {
!outline.overflow && self.cells(edge_count(outline)) > 0
}
}
fn edge_count(outline: &Outline) -> usize {
outline.subpaths.iter().map(Vec::len).sum()
}
/// A disc inside the fill.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Disc {
pub centre: (f64, f64),
pub radius: f64,
}
/// What the search looks for, in user units: cells that cannot reach `floor` are dropped, the
/// search stops at a disc of `enough`, and no cell is cut below `precision`.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Search {
pub floor: f64,
pub enough: f64,
pub precision: f64,
}
/// The fill outline of a polygon or a path, chords at most `tolerance` from the curves; `None`
/// for a circle (its disc is exact) and for path data a browser would not read whole.
pub fn geometry_outline(geometry: &Geometry, tolerance: f64) -> Option<Outline> {
match geometry {
Geometry::Circle(_) => None,
Geometry::Polygon(p) => Some(Outline {
subpaths: vec![p.points.iter().map(|p| (p.0, p.1)).collect()],
deviation: 0.0,
overflow: p.points.len() > MAX_OUTLINE_VERTICES,
}),
Geometry::Path(path) => path_outline(&path.d, tolerance, MAX_OUTLINE_VERTICES),
}
}
/// The widest disc found inside the outline's fill under `rule`, its radius net of the chord
/// deviation, the work taken from `budget`; `None` when the search shows none.
pub fn widest_disc(
outline: &Outline,
rule: FillRule,
search: &Search,
budget: &mut Budget,
) -> Option<Disc> {
let edges = edge_count(outline);
let affordable = budget.cells(edges);
if affordable == 0 {
return None;
}
let mut points = outline.subpaths.iter().flatten();
let first = *points.next()?;
let (min, max) = points.fold((first, first), |(min, max), &(x, y)| {
((min.0.min(x), min.1.min(y)), (max.0.max(x), max.1.max(y)))
});
let half = (max.0 - min.0).max(max.1 - min.1) / 2.0;
let root = Cell::new(outline, rule, (min.0 + half, min.1 + half), half);
let mut best = root.disc();
let mut cells = BinaryHeap::from([root]);
let mut evaluated = 1;
while let Some(cell) = cells.pop() {
let widest = best.map_or(0.0, |disc| disc.radius);
// The heap gives the cell of greatest reach: when it cannot do better, none can.
if widest >= search.enough
|| cell.reach() < search.floor
|| cell.reach() <= widest + search.precision
|| evaluated + 4 > affordable
{
break;
}
if cell.half * SQRT_2 <= search.precision {
continue;
}
let quarter = cell.half / 2.0;
for (dx, dy) in [(-1.0, -1.0), (1.0, -1.0), (-1.0, 1.0), (1.0, 1.0)] {
let centre = (cell.centre.0 + dx * quarter, cell.centre.1 + dy * quarter);
let child = Cell::new(outline, rule, centre, quarter);
if child.radius > best.map_or(0.0, |disc| disc.radius) {
best = child.disc();
}
cells.push(child);
}
evaluated += 4;
}
budget.work -= evaluated * edges;
best
}
/// A square cell of the search: its centre's radius and its half side.
struct Cell {
centre: (f64, f64),
half: f64,
radius: f64,
}
impl Cell {
fn new(outline: &Outline, rule: FillRule, centre: (f64, f64), half: f64) -> Self {
let radius = clearance(outline, rule, centre) - outline.deviation;
Self {
centre,
half,
radius,
}
}
/// The widest radius a centre inside the cell could have.
fn reach(&self) -> f64 {
self.radius + self.half * SQRT_2
}
fn disc(&self) -> Option<Disc> {
(self.radius > 0.0).then_some(Disc {
centre: self.centre,
radius: self.radius,
})
}
}
impl Ord for Cell {
fn cmp(&self, other: &Self) -> Ordering {
self.reach().total_cmp(&other.reach())
}
}
impl PartialOrd for Cell {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(self.cmp(other))
}
}
impl PartialEq for Cell {
fn eq(&self, other: &Self) -> bool {
self.cmp(other) == Ordering::Equal
}
}
impl Eq for Cell {}
/// The distance from `point` to the nearest edge, negative when the fill leaves it out.
fn clearance(outline: &Outline, rule: FillRule, point: (f64, f64)) -> f64 {
let mut nearest = f64::INFINITY;
let mut winding = 0_i64;
for subpath in &outline.subpaths {
let closing = subpath.last().into_iter().chain(subpath.iter());
for (&a, &b) in closing.zip(subpath.iter()) {
nearest = nearest.min(segment_distance(point, a, b));
winding += crossing(point, a, b);
}
}
let inside = match rule {
FillRule::NonZero => winding != 0,
FillRule::EvenOdd => winding % 2 != 0,
};
if inside { nearest } else { -nearest }
}
/// +1 or −1 when the edge crosses the horizontal ray to the right of `point` upwards or
/// downwards, else 0.
fn crossing(point: (f64, f64), a: (f64, f64), b: (f64, f64)) -> i64 {
let side = (b.0 - a.0) * (point.1 - a.1) - (point.0 - a.0) * (b.1 - a.1);
if a.1 <= point.1 && point.1 < b.1 && side > 0.0 {
1
} else if b.1 <= point.1 && point.1 < a.1 && side < 0.0 {
-1
} else {
0
}
}
fn segment_distance(p: (f64, f64), a: (f64, f64), b: (f64, f64)) -> f64 {
let (dx, dy) = (b.0 - a.0, b.1 - a.1);
let length = dx * dx + dy * dy;
let t = if length > 0.0 {
(((p.0 - a.0) * dx + (p.1 - a.1) * dy) / length).clamp(0.0, 1.0)
} else {
0.0
};
(p.0 - a.0 - t * dx).hypot(p.1 - a.1 - t * dy)
}
#[cfg(test)]
#[allow(clippy::unwrap_used)]
mod tests {
use super::*;
const MEASURE: Search = Search {
floor: 0.0,
enough: f64::INFINITY,
precision: 1e-3,
};
fn polygon(points: &[(f64, f64)]) -> Outline {
Outline {
subpaths: vec![points.to_vec()],
..Outline::default()
}
}
fn widest(outline: &Outline, rule: FillRule) -> f64 {
measure(outline, rule).map_or(0.0, |d| d.radius)
}
fn measure(outline: &Outline, rule: FillRule) -> Option<Disc> {
widest_disc(outline, rule, &MEASURE, &mut Budget::default())
}
#[test]
fn a_square_holds_its_inscribed_disc() {
let square = polygon(&[(0.0, 0.0), (10.0, 0.0), (10.0, 10.0), (0.0, 10.0)]);
let r = widest(&square, FillRule::NonZero);
assert!((r - 5.0).abs() < 2e-3, "{r}");
}
/// A pentagram: its centre has winding 2, filled under nonzero, a hole under evenodd.
#[test]
fn the_fill_rule_decides_a_self_intersection() {
let star: Vec<(f64, f64)> = (0..5)
.map(|i| {
let angle =
std::f64::consts::FRAC_PI_2 + f64::from(i * 2) * std::f64::consts::TAU / 5.0;
(100.0 * angle.cos(), 100.0 * angle.sin())
})
.collect();
let star = polygon(&star);
let nonzero = widest(&star, FillRule::NonZero);
let evenodd = widest(&star, FillRule::EvenOdd);
// Conservative: the disc crosses no edge, so it stops at the inner pentagon's inscribed
// radius, 100 × cos 72° ≈ 30.9, where the fill itself reaches the concave corners at
// 38.2; under evenodd the centre is a hole and only a tip's disc remains.
assert!(
(nonzero - 100.0 * 72_f64.to_radians().cos()).abs() < 0.01,
"{nonzero}"
);
// A tip, an isosceles triangle of apex 36°: inscribed radius 16.31.
assert!((evenodd - 16.31).abs() < 0.01, "{evenodd}");
let centre = clearance(&star, FillRule::EvenOdd, (0.0, 0.0));
assert!(centre < 0.0, "the centre is a hole under evenodd");
}
#[test]
fn an_outline_drawn_forth_and_back_fills_nothing() {
let there_and_back = polygon(&[(0.0, 0.0), (50.0, 0.0), (50.0, 50.0), (50.0, 0.0)]);
for rule in [FillRule::NonZero, FillRule::EvenOdd] {
assert!(measure(&there_and_back, rule).is_none());
}
// Two opposite loops over the same square: winding 0 under nonzero, 2 even.
let square = [(0.0, 0.0), (10.0, 0.0), (10.0, 10.0), (0.0, 10.0)];
let mut reversed = square;
reversed.reverse();
let both = Outline {
subpaths: vec![square.to_vec(), reversed.to_vec()],
..Outline::default()
};
assert!(measure(&both, FillRule::NonZero).is_none());
assert!(measure(&both, FillRule::EvenOdd).is_none());
}
#[test]
fn the_deviation_is_taken_off() {
let mut square = polygon(&[(0.0, 0.0), (10.0, 0.0), (10.0, 10.0), (0.0, 10.0)]);
square.deviation = 1.0;
let r = widest(&square, FillRule::NonZero);
assert!((r - 4.0).abs() < 2e-3, "{r}");
}
#[test]
fn the_search_stops_at_enough_and_drops_cells_below_the_floor() {
let square = polygon(&[(0.0, 0.0), (10.0, 0.0), (10.0, 10.0), (0.0, 10.0)]);
let enough = Search {
floor: 2.0,
enough: 2.0,
precision: 1e-3,
};
let disc =
widest_disc(&square, FillRule::NonZero, &enough, &mut Budget::default()).unwrap();
assert!(disc.radius >= 2.0);
let out_of_reach = Search {
floor: 5.1,
enough: 5.1,
precision: 1e-3,
};
let disc = widest_disc(
&square,
FillRule::NonZero,
&out_of_reach,
&mut Budget::default(),
);
assert!(disc.is_none_or(|d| d.radius < 5.1));
}
/// The budget counts edge distances across shapes; a shape it cannot afford is not measured.
#[test]
fn the_budget_is_shared_and_spent() {
let square = polygon(&[(0.0, 0.0), (10.0, 0.0), (10.0, 10.0), (0.0, 10.0)]);
let mut budget = Budget { work: 4 * 9 };
assert!(budget.affords(&square));
let small = widest_disc(&square, FillRule::NonZero, &MEASURE, &mut budget);
assert!(small.is_some(), "the root cell finds the centre");
assert_eq!(budget.work, 0, "nine cells: the root and two cuts of four");
let mut spent = Budget { work: 3 };
assert!(!spent.affords(&square));
assert!(widest_disc(&square, FillRule::NonZero, &MEASURE, &mut spent).is_none());
let mut too_many = square.clone();
too_many.overflow = true;
assert!(!Budget::default().affords(&too_many));
}
#[test]
fn every_centre_found_holds_its_disc() {
let comb = polygon(&[
(0.0, 0.0),
(30.0, 0.0),
(30.0, 10.0),
(20.0, 10.0),
(20.0, 2.0),
(10.0, 2.0),
(10.0, 10.0),
(0.0, 10.0),
]);
let disc = measure(&comb, FillRule::NonZero).unwrap();
for i in 0..64 {
let angle = f64::from(i) * std::f64::consts::TAU / 64.0;
let at = (
disc.centre.0 + 0.999 * disc.radius * angle.cos(),
disc.centre.1 + 0.999 * disc.radius * angle.sin(),
);
assert!(clearance(&comb, FillRule::NonZero, at) > 0.0, "{at:?}");
}
assert!((disc.radius - 5.0).abs() < 2e-3, "{disc:?}");
}
/// A deterministic generator for the sampled comparisons.
struct Lcg(u64);
impl Lcg {
fn next(&mut self, low: f64, high: f64) -> f64 {
self.0 = self
.0
.wrapping_mul(6_364_136_223_846_793_005)
.wrapping_add(1_442_695_040_888_963_407);
low + (high - low) * ((self.0 >> 11) as f64 / (1_u64 << 53) as f64)
}
}
/// Random polygons, self-intersecting ones included, under both rules: the disc found never
/// beats a dense grid of centres by more than the grid's half diagonal, and every point of
/// its rim is filled.
#[test]
fn the_disc_found_is_never_wider_than_the_fill() {
let mut rng = Lcg(5);
for case in 0..60 {
let count = 3 + (case % 7);
let points: Vec<(f64, f64)> = (0..count)
.map(|_| (rng.next(0.0, 40.0), rng.next(0.0, 40.0)))
.collect();
let shape = polygon(&points);
for rule in [FillRule::NonZero, FillRule::EvenOdd] {
let Some(disc) = measure(&shape, rule) else {
continue;
};
let mut grid = 0.0_f64;
for i in 0..=200 {
for j in 0..=200 {
let at = (0.2 * f64::from(i), 0.2 * f64::from(j));
grid = grid.max(clearance(&shape, rule, at));
}
}
assert!(
disc.radius <= grid + 0.15,
"case {case}: {disc:?} vs {grid}"
);
for k in 0..90 {
let angle = f64::from(k) * std::f64::consts::TAU / 90.0;
let rim = (
disc.centre.0 + 0.999 * disc.radius * angle.cos(),
disc.centre.1 + 0.999 * disc.radius * angle.sin(),
);
assert!(clearance(&shape, rule, rim) > 0.0, "case {case}: {rim:?}");
}
}
}
}
}
+1
View File
@@ -5,6 +5,7 @@
pub mod compose;
pub mod frame;
pub mod interior;
pub mod layer;
pub mod path;
pub mod svg;
+257 -7
View File
@@ -10,6 +10,10 @@
//! `f32::MAX` (Chromium, WebKit; WebKit already for an arc radius of `1e30`), while a radius or a
//! rotation that big leaves the bounds unchanged. A coordinate past the bound is outside every
//! usable frame, a radius past it draws a straight segment on one.
//!
//! The same reading gives a path's fill outline (`path_outline`, owner brief 2026-11-01, zone
//! without interior): each subpath as a polyline, curves and arcs cut into chords, with the
//! largest distance between a chord and its curve (`Outline::deviation`).
/// The smallest box holding a set of points.
#[derive(Debug, Clone, Copy, PartialEq)]
@@ -55,8 +59,45 @@ pub fn number_list(value: &str) -> Option<Vec<f64>> {
/// The bounds of every point `d` draws; `None` when a browser would not read all of it.
pub fn path_bounds(d: &str) -> Option<Bounds> {
let mut cursor = Cursor::new(d);
let mut pen = Pen::default();
read_path(d, &mut pen)?;
pen.bounds
}
/// The largest number of chords a curve or an arc is cut into: past it the deviation grows
/// instead (the measure stays conservative).
pub const MAX_CURVE_CHORDS: usize = 64;
/// A fill outline: its subpaths as polylines (each closed by the fill), the largest distance
/// between a chord and the curve it stands for, and whether more than the asked number of
/// vertices was needed (the outline is then incomplete).
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Outline {
pub subpaths: Vec<Vec<(f64, f64)>>,
pub deviation: f64,
pub overflow: bool,
}
/// The outline `d` fills, curves and arcs cut into chords at most `tolerance` away from them
/// (`MAX_CURVE_CHORDS` aside), at most `max_vertices` vertices; `None` when a browser would not
/// read all of it.
pub fn path_outline(d: &str, tolerance: f64, max_vertices: usize) -> Option<Outline> {
let mut pen = Pen {
flat: Some(Flattening {
tolerance,
max_vertices,
vertices: 0,
start: None,
outline: Outline::default(),
}),
..Pen::default()
};
read_path(d, &mut pen)?;
Some(pen.flat?.outline)
}
fn read_path(d: &str, pen: &mut Pen) -> Option<()> {
let mut cursor = Cursor::new(d);
cursor.skip_space();
if !matches!(cursor.peek(), Some(b'M' | b'm')) {
return None;
@@ -74,10 +115,7 @@ pub fn path_bounds(d: &str) -> Option<Bounds> {
}
}
}
if !cursor.done() {
return None;
}
pen.bounds
cursor.done().then_some(())
}
/// A position in the text being read.
@@ -245,8 +283,8 @@ struct Arc {
to: (f64, f64),
}
/// The current point, the subpath start, the previous control point (for `S` and `T`), and
/// the bounds so far.
/// The current point, the subpath start, the previous control point (for `S` and `T`), the
/// bounds so far, and the outline when one is asked.
#[derive(Default)]
struct Pen {
at: (f64, f64),
@@ -254,6 +292,44 @@ struct Pen {
cubic_control: Option<(f64, f64)>,
quadratic_control: Option<(f64, f64)>,
bounds: Option<Bounds>,
flat: Option<Flattening>,
}
/// The outline being drawn: a subpath starts with the first point drawn after its moveto or
/// closepath, so a lone moveto adds nothing.
struct Flattening {
tolerance: f64,
max_vertices: usize,
vertices: usize,
start: Option<(f64, f64)>,
outline: Outline,
}
impl Flattening {
fn push(&mut self, point: (f64, f64)) {
if let Some(start) = self.start.take() {
self.outline.subpaths.push(Vec::new());
self.push(start);
}
if self.vertices == self.max_vertices {
self.outline.overflow = true;
return;
}
self.vertices += 1;
if let Some(subpath) = self.outline.subpaths.last_mut() {
subpath.push(point);
}
}
/// The chords for a curve whose second derivative stays within `bend`: a chord over a
/// parameter step `h` departs from the curve by at most `bend × h² / 8`.
fn chords(&mut self, bend: f64) -> usize {
let wanted = (bend / (8.0 * self.tolerance)).sqrt().ceil();
let count = wanted.clamp(1.0, MAX_CURVE_CHORDS as f64) as usize;
let step = 1.0 / count as f64;
self.outline.deviation = self.outline.deviation.max(bend * step * step / 8.0);
count
}
}
impl Pen {
@@ -264,10 +340,32 @@ impl Pen {
}
}
/// Starts a subpath of the outline at the current point, once something is drawn from it.
fn open_subpath(&mut self) {
if let Some(flat) = &mut self.flat {
flat.start = Some(self.at);
}
}
/// The points of a curve between its ends, `count` chords over `t` in (0, 1).
fn trace(&mut self, count: usize, at: impl Fn(f64) -> (f64, f64)) {
if let Some(flat) = &mut self.flat {
for i in 1..count {
flat.push(at(i as f64 / count as f64));
}
}
}
fn chords(&mut self, bend: f64) -> usize {
self.flat.as_mut().map_or(1, |flat| flat.chords(bend))
}
/// A drawing command after a closepath starts a new subpath at the closed one's start.
fn close(&mut self) {
self.at = self.start;
self.cubic_control = None;
self.quadratic_control = None;
self.open_subpath();
}
/// One parameter group of `command`; a moveto's later pairs are linetos.
@@ -282,6 +380,7 @@ impl Pen {
self.at = point(x, y);
self.start = self.at;
self.add(self.at);
self.open_subpath();
self.cubic_control = None;
self.quadratic_control = None;
return self.linetos(relative, cursor);
@@ -343,6 +442,9 @@ impl Pen {
fn line(&mut self, to: (f64, f64)) {
self.add(to);
if let Some(flat) = &mut self.flat {
flat.push(to);
}
self.at = to;
}
@@ -359,6 +461,16 @@ impl Pen {
cubic_at(from.1, c1.1, c2.1, to.1, t),
));
}
let bend = 6.0
* distance(second_difference(from, c1, c2))
.max(distance(second_difference(c1, c2, to)));
let count = self.chords(bend);
self.trace(count, |t| {
(
cubic_at(from.0, c1.0, c2.0, to.0, t),
cubic_at(from.1, c1.1, c2.1, to.1, t),
)
});
self.line(to);
c2
}
@@ -378,6 +490,13 @@ impl Pen {
quadratic_at(from.1, control.1, to.1, t),
));
}
let count = self.chords(2.0 * distance(second_difference(from, control, to)));
self.trace(count, |t| {
(
quadratic_at(from.0, control.0, to.0, t),
quadratic_at(from.1, control.1, to.1, t),
)
});
self.line(to);
control
}
@@ -398,10 +517,23 @@ impl Pen {
self.add(ellipse.at(angle));
}
}
// Over the sweep as `t` goes from 0 to 1 the second derivative stays within the larger
// radius times the sweep squared.
let count = self.chords(ellipse.rx.max(ellipse.ry) * ellipse.sweep * ellipse.sweep);
self.trace(count, |t| ellipse.at(ellipse.start + ellipse.sweep * t));
self.line(arc.to);
}
}
/// `a − 2b + c`, the curve's second difference over three control points.
fn second_difference(a: (f64, f64), b: (f64, f64), c: (f64, f64)) -> (f64, f64) {
(a.0 - 2.0 * b.0 + c.0, a.1 - 2.0 * b.1 + c.1)
}
fn distance((x, y): (f64, f64)) -> f64 {
x.hypot(y)
}
/// The reflection of the previous control point about the current point, or the current point.
fn reflect(control: Option<(f64, f64)>, at: (f64, f64)) -> (f64, f64) {
control.map_or(at, |(x, y)| (2.0 * at.0 - x, 2.0 * at.1 - y))
@@ -637,6 +769,124 @@ mod tests {
}
}
/// A curve by its parameter in [0, 1].
type Curve<'a> = Box<dyn Fn(f64) -> (f64, f64) + 'a>;
fn polyline_distance(point: (f64, f64), line: &[(f64, f64)]) -> f64 {
line.windows(2)
.map(|pair| {
let (a, b) = (pair[0], pair[1]);
let (dx, dy) = (b.0 - a.0, b.1 - a.1);
let length = dx * dx + dy * dy;
let t = if length > 0.0 {
(((point.0 - a.0) * dx + (point.1 - a.1) * dy) / length).clamp(0.0, 1.0)
} else {
0.0
};
(point.0 - a.0 - t * dx).hypot(point.1 - a.1 - t * dy)
})
.fold(f64::INFINITY, f64::min)
}
/// Every point of the curve lies within the declared deviation of its chords, and the
/// deviation within the tolerance asked unless the curve took `MAX_CURVE_CHORDS` (an arc
/// whose radii the endpoints scale up).
#[test]
fn outline_chords_stay_within_the_deviation() {
let mut rng = Lcg(13);
let tolerance = 0.05;
for case in 0..300 {
let p: Vec<f64> = (0..8).map(|_| rng.next(-50.0, 50.0)).collect();
let arc = Arc {
rx: rng.next(0.5, 30.0),
ry: rng.next(0.5, 30.0),
rotation: rng.next(-360.0, 360.0),
large: rng.next(0.0, 1.0) < 0.5,
sweep: rng.next(0.0, 1.0) < 0.5,
to: (p[6], p[7]),
};
let curves: [(String, Curve<'_>); 3] = [
(
format!(
"M{} {}C{} {} {} {} {} {}",
p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]
),
Box::new(|t| {
(
cubic_at(p[0], p[2], p[4], p[6], t),
cubic_at(p[1], p[3], p[5], p[7], t),
)
}),
),
(
format!("M{} {}Q{} {} {} {}", p[0], p[1], p[2], p[3], p[6], p[7]),
Box::new(|t| {
(
quadratic_at(p[0], p[2], p[6], t),
quadratic_at(p[1], p[3], p[7], t),
)
}),
),
(
format!(
"M{} {}A{} {} {} {} {} {} {}",
p[0],
p[1],
arc.rx,
arc.ry,
arc.rotation,
u8::from(arc.large),
u8::from(arc.sweep),
p[6],
p[7]
),
{
let ellipse = Ellipse::through((p[0], p[1]), &arc);
Box::new(move |t| ellipse.at(ellipse.start + ellipse.sweep * t))
},
),
];
for (d, at) in &curves {
let outline = path_outline(d, tolerance, 4096).unwrap();
assert_eq!(outline.subpaths.len(), 1, "{d}");
let line = &outline.subpaths[0];
let capped = line.len() == MAX_CURVE_CHORDS + 1;
assert!(
outline.deviation <= tolerance || capped,
"case {case} {d}: {}",
outline.deviation
);
for i in 0..=2000 {
let point = at(f64::from(i) / 2000.0);
let gap = polyline_distance(point, line);
assert!(gap <= outline.deviation + 1e-9, "case {case} {d}: {gap}");
}
}
}
}
#[test]
fn a_closepath_starts_the_next_subpath_at_its_start() {
let outline = path_outline("M0 0h10v10h-10zh-10v10h10z", 0.05, 4096).unwrap();
assert_eq!(
outline.subpaths,
[
vec![(0.0, 0.0), (10.0, 0.0), (10.0, 10.0), (0.0, 10.0)],
vec![(0.0, 0.0), (-10.0, 0.0), (-10.0, 10.0), (0.0, 10.0)],
]
);
assert_eq!(outline.deviation, 0.0);
let lone = path_outline("M5 5M0 0h1v1z", 0.05, 4096).unwrap();
assert_eq!(lone.subpaths.len(), 1, "a lone moveto fills nothing");
}
#[test]
fn the_outline_stops_at_its_vertex_cap() {
let d = format!("M0 0{}", "l1 1".repeat(9));
assert!(!path_outline(&d, 0.05, 10).unwrap().overflow);
assert!(path_outline(&d, 0.05, 9).unwrap().overflow);
}
#[test]
fn the_grammar_is_read_as_a_browser_reads_it() {
let read = |d: &str| path_bounds(d).map(|b| (b.min_x, b.min_y, b.max_x, b.max_y));
+11
View File
@@ -28,6 +28,9 @@ pub const NO_FRAME: &str = "view.frame.unknown";
/// An annotation in frame that shows below `anatomy::frame::MIN_VISIBLE_PX` on the smallest
/// preview (owner brief 2026-11-01, the scale bypass).
pub const TOO_SMALL: &str = "annotation.geometry.too_small";
/// A polygon or a path in frame whose fill holds no disc of `anatomy::frame::MIN_VISIBLE_PX` on
/// the smallest preview (owner brief 2026-11-01, zone without interior; `anatomy::interior`).
pub const INTERIOR_TOO_SMALL: &str = "annotation.geometry.interior_too_small";
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
#[cfg_attr(feature = "ts", derive(TS), ts(export))]
@@ -123,6 +126,14 @@ fn frame_issue(document: &AnatomicalSheetDocument, fault: &FrameFault) -> SheetI
let (code, what) = match placement {
Placement::Unreadable => (OUT_OF_FRAME, "has path data that cannot be read whole"),
Placement::TooSmall => (TOO_SMALL, "shows too small on the phone preview"),
Placement::InteriorTooSmall => (
INTERIOR_TOO_SMALL,
"fills no interior wide enough to tap on the phone preview",
),
Placement::InteriorUnmeasured => (
INTERIOR_TOO_SMALL,
"is too complex for the interior measure on the phone preview",
),
Placement::InFrame | Placement::OutOfFrame => {
(OUT_OF_FRAME, "is not entirely inside the frame")
}
+9 -2
View File
@@ -21,8 +21,8 @@ use ts_rs::TS;
use super::caps::CapsReport;
use super::fingerprint::{FingerprintError, document_fingerprint};
use super::report::{
NO_FRAME, OUT_OF_FRAME, SheetReport, TOO_SMALL, frame_issues, referenced_asset_ids,
sheet_report,
INTERIOR_TOO_SMALL, NO_FRAME, OUT_OF_FRAME, SheetReport, TOO_SMALL, frame_issues,
referenced_asset_ids, sheet_report,
};
use super::review::{Completeness, ElementChange, ReviewGroup, change_list};
use super::schema::AnatomicalSheetDocument;
@@ -58,6 +58,9 @@ pub mod codes {
/// An annotation in frame that shows below 4 CSS px on the smallest preview (owner brief
/// 2026-11-01): measured on the same views.
pub const MARKER_TOO_SMALL: &str = "verification.validation.marker_too_small";
/// A polygon or a path in frame whose fill holds no disc of 4 CSS px on that preview, its
/// stroke left out (owner brief 2026-11-01, zone without interior).
pub const MARKER_INTERIOR_TOO_SMALL: &str = "verification.validation.marker_interior_too_small";
pub const FINGERPRINT: &str = "verification.integrity.fingerprint";
}
@@ -285,6 +288,7 @@ fn rule_failures(report: &SheetReport) -> Vec<&'static str> {
OUT_OF_FRAME,
NO_FRAME,
TOO_SMALL,
INTERIOR_TOO_SMALL,
]
.contains(&code)
};
@@ -316,6 +320,9 @@ fn frame_failures(report: &SheetReport) -> Vec<&'static str> {
if found(&[TOO_SMALL]) {
out.push(codes::MARKER_TOO_SMALL);
}
if found(&[INTERIOR_TOO_SMALL]) {
out.push(codes::MARKER_INTERIOR_TOO_SMALL);
}
out
}
+232
View File
@@ -0,0 +1,232 @@
//! The browser proof of the interior rule (owner brief « V1-2.2 : fermeture du dernier MEDIUM »,
//! 2026-11-01): `apps/app/e2e/fixtures/interior-probe.json`, read by
//! `apps/app/e2e/ui/interior-clicks.spec.ts` in Chromium, Firefox and WebKit. Each case is a
//! sheet whose main view, framed `0 0 286 310` (one unit per CSS px on the phone preview), holds
//! one shape: the canvas the editor gets (`view.canvas`), the verdict's code, and the widest disc
//! the core measures. The equine draft's shapes give their discs too. The file is generated
//! here and compared byte for byte; `MAKE_INTERIOR_PROBE=1` writes it.
#![allow(clippy::disallowed_methods, clippy::unwrap_used, clippy::expect_used)]
mod common;
use common::sheet_readers::{DETAIL_ASSET, MAIN_ASSET, OPEN, document, drawing};
use faunosteo_core::anatomy::interior::{
Budget, LAYER_FILL_RULE, Search, geometry_outline, widest_disc,
};
use faunosteo_core::domain::sheet::preview::{PreviewInput, PreviewSheet, PreviewStatus};
use faunosteo_core::domain::sheet::{AnatomicalSheetDocument, Annotation, Geometry};
use faunosteo_core::facade::call_with_preview;
use serde_json::{Value, json};
const FIXTURE: &str = "apps/app/e2e/fixtures/interior-probe.json";
const THIN: &str = "annotation.geometry.interior_too_small";
const PHONE: &str = "0 0 286 310";
/// The widest disc of a shape, measured to a thousandth of a unit: centre and radius.
fn widest(geometry: &Geometry) -> Value {
let outline = geometry_outline(geometry, 0.001).unwrap();
let search = Search {
floor: 0.0,
enough: f64::INFINITY,
precision: 0.001,
};
match widest_disc(&outline, LAYER_FILL_RULE, &search, &mut Budget::default()) {
Some(disc) => json!({
"x": round(disc.centre.0),
"y": round(disc.centre.1),
"r": round(disc.radius),
}),
None => Value::Null,
}
}
fn round(value: f64) -> f64 {
(value * 1000.0).round() / 1000.0
}
/// One case: the canvas, the frame codes, the widest disc.
fn case(name: &str, geometry: Value, root: &str) -> Value {
let mut doc: Value = serde_json::from_str(&document()).unwrap();
doc["annotations"][0]["id"] = json!("shape");
doc["annotations"][0]["kind"] = json!("zone");
doc["annotations"][0]["geometry"] = geometry.clone();
let main = OPEN.replace(
"viewBox=\"0 0 10 10\"",
&format!("{root}viewBox=\"{PHONE}\""),
) + "<path d=\"M0 0h1\"/></svg>";
let detail = OPEN.to_owned() + "<path d=\"M0 0h1\"/></svg>";
let input = PreviewInput {
status: PreviewStatus::Draft,
document: doc.to_string(),
fingerprint: None,
};
let preview = PreviewSheet::load(
input,
vec![drawing(MAIN_ASSET, &main), drawing(DETAIL_ASSET, &detail)],
)
.unwrap();
let codes: Vec<String> = preview
.state()
.unwrap()
.report
.issues
.iter()
.filter(|i| i.code.starts_with("annotation.geometry."))
.map(|i| i.code.clone())
.collect();
let canvas: Value = serde_json::from_str(&call_with_preview(
&preview,
"view.canvas",
&json!({ "viewId": "main" }).to_string(),
))
.unwrap();
assert_eq!(canvas["ok"], json!(true), "{name}: {canvas}");
let typed: Geometry = serde_json::from_value(geometry).unwrap();
json!({
"name": name,
"accepted": codes.is_empty(),
"codes": codes,
"widest": widest(&typed),
"svg": canvas["value"]["svg"],
})
}
fn polygon(points: &[[f64; 2]]) -> Value {
json!({ "type": "polygon", "points": points })
}
fn path(d: &str) -> Value {
json!({ "type": "path", "d": d })
}
fn ell(x: f64, y: f64, w: f64) -> Value {
polygon(&[
[x, y],
[x + 40.0, y],
[x + 40.0, y + w],
[x + w, y + w],
[x + w, y + 40.0],
[x, y + 40.0],
])
}
fn star(cx: f64, cy: f64, r: f64) -> Value {
let points: Vec<[f64; 2]> = (0..5)
.map(|i| {
let angle =
-std::f64::consts::FRAC_PI_2 + f64::from(i * 2) * std::f64::consts::TAU / 5.0;
[cx + r * angle.cos(), cy + r * angle.sin()]
})
.collect();
polygon(&points)
}
fn cases() -> Vec<Value> {
let plain = "";
vec![
// Accepted: small shapes that fill.
case(
"square-6",
polygon(&[[40.0, 40.0], [46.0, 40.0], [46.0, 46.0], [40.0, 46.0]]),
plain,
),
case(
"flat-triangle",
polygon(&[[40.0, 40.0], [100.0, 40.0], [70.0, 44.6]]),
plain,
),
case(
"arc-disc-6",
path("M40 50a3 3 0 1 0 6 0a3 3 0 1 0 -6 0Z"),
plain,
),
case(
"cubic-lens",
path("M40 50C50 44 70 44 80 50C70 56 50 56 40 50Z"),
plain,
),
case("ell-3.6", ell(40.0, 40.0, 3.6), plain),
// Winding 2 at the centre: filled by the layer's nonzero rule, whatever the drawing says.
case(
"pentagram-evenodd-root",
star(60.0, 60.0, 10.0),
"fill-rule=\"evenodd\" ",
),
// Refused: no interior a tap reaches on the phone.
case("forth-and-back", path("M40 40L90 90L40 40"), plain),
case(
"square-twice-opposite",
path("M40 40h40v40h-40zM40 40v40h40v-40z"),
plain,
),
case(
"diagonal-sliver",
polygon(&[[40.0, 40.0], [90.0, 90.0], [90.0, 88.6]]),
plain,
),
case(
"cubic-there-and-back",
path("M40 80C50 40 80 40 90 80C80 40 50 40 40 80Z"),
plain,
),
case(
"arc-there-and-back",
path("M40 80A25 25 0 0 1 90 80A25 25 0 0 0 40 80Z"),
plain,
),
case(
"flat-ellipse-45",
path("M40 40A35 1 45 0 1 90 90A35 1 45 0 1 40 40Z"),
plain,
),
case("ell-3.3", ell(40.0, 40.0, 3.3), plain),
case(
"triangle-6.6",
polygon(&[[40.0, 45.716], [46.6, 45.716], [43.3, 40.0]]),
plain,
),
]
}
/// The equine draft's polygons and paths: their widest disc, in the frame's units.
fn equine() -> Vec<Value> {
let text = common::repo_file("supabase/seed/anatomical-sheets/equine/draft/document.json");
let doc: AnatomicalSheetDocument = serde_json::from_str(&text).unwrap();
doc.annotations
.iter()
.filter_map(|a| {
let geometry = match a {
Annotation::Observable(o) => o.geometry.as_ref(),
Annotation::DetailTrigger(t) => t.geometry.as_ref(),
}?;
if matches!(geometry, Geometry::Circle(_)) {
return None;
}
Some(json!({ "id": a.id(), "view": a.view_id(), "widest": widest(geometry) }))
})
.collect()
}
#[test]
fn the_interior_probe_is_current() {
let cases = cases();
for c in &cases {
let refused = c["codes"] == json!([THIN]);
assert!(c["accepted"] == json!(true) || refused, "{}", c["name"]);
}
let probe = json!({
"generatedBy": "crates/core/tests/interior_probe.rs",
"frame": { "width": 286, "height": 310 },
"cases": cases,
"equine": equine(),
});
let text = serde_json::to_string_pretty(&probe).unwrap() + "\n";
let path = format!("{}/../../{FIXTURE}", env!("CARGO_MANIFEST_DIR"));
if std::env::var("MAKE_INTERIOR_PROBE").is_ok_and(|v| v == "1") {
std::fs::write(&path, &text).unwrap();
}
assert!(
common::repo_file(FIXTURE) == text,
"{FIXTURE} is stale: MAKE_INTERIOR_PROBE=1 cargo test --test interior_probe"
);
}
+188 -15
View File
@@ -24,10 +24,12 @@ use serde_json::{Value, json};
const SEED: &str = "supabase/seed/anatomical-sheets/equine/draft";
const HORSE_ID: &str = "7f767f74-3b36-51a7-8465-52dd7e2ead4a";
const TOO_SMALL: &str = "annotation.geometry.too_small";
const THIN: &str = "annotation.geometry.interior_too_small";
const NO_FRAME: &str = "view.frame.unknown";
const OUT_OF_FRAME: &str = "annotation.geometry.out_of_frame";
/// The verdict's closed codes, as the SQL stores them.
const SMALL_FAILURE: &str = "verification.validation.marker_too_small";
const THIN_FAILURE: &str = "verification.validation.marker_interior_too_small";
const FRAME_FAILURE: &str = "verification.validation.out_of_frame";
/// The frame and size issues `(code, path)`, the verdict and the preview agreeing, and the
@@ -68,7 +70,7 @@ fn judged(
let state = PreviewSheet::load(input, given).unwrap().state().unwrap();
let issues = |all: &[faunosteo_core::domain::sheet::SheetIssue]| -> Vec<(String, String)> {
all.iter()
.filter(|i| [TOO_SMALL, NO_FRAME, OUT_OF_FRAME].contains(&i.code.as_str()))
.filter(|i| [TOO_SMALL, THIN, NO_FRAME, OUT_OF_FRAME].contains(&i.code.as_str()))
.map(|i| (i.code.clone(), i.path.clone()))
.collect()
};
@@ -179,28 +181,50 @@ fn the_blown_up_horse_is_refused() {
assert_eq!(text, equine(), "the document is never rewritten");
}
/// The threshold on the real sheet: the junctions fall below 4 px once the horse is scaled by
/// more than 4.966 / 4 ≈ 1.2414; the other points (disc r 22) hold until ≈ 1.517.
/// The threshold on the real sheet. The caudal zone's widest disc (4.951 px) falls below 4 px
/// first, once the horse is scaled by more than 4.951 / 4 ≈ 1.2378; then the junctions, past
/// 4.966 / 4 ≈ 1.2414; the other points (disc r 22) hold until ≈ 1.517, the other zones (at
/// least 11.30 px) until ≈ 2.8. In doubt the measure refuses: at 1.236 (4.006 px) the search,
/// which cuts no cell below 0.05 px, has not shown the disc.
#[test]
fn the_equine_threshold_falls_on_the_junctions_first() {
fn the_equine_threshold_falls_on_the_caudal_zone_then_the_junctions() {
let text = equine();
let small = |factor: f64| -> Vec<String> {
let small = |factor: f64| -> Vec<(String, String)> {
let (issues, _) = judged(&text, &[(HORSE_ID, &scaled_horse(factor))]);
let doc: Value = serde_json::from_str(&text).unwrap();
issues
let mut found: Vec<(String, String)> = issues
.iter()
.map(|(_, path)| {
.map(|(code, path)| {
let index: usize = path[12..path.len() - 10].parse().unwrap();
doc["annotations"][index]["id"].as_str().unwrap().to_owned()
let id = doc["annotations"][index]["id"].as_str().unwrap();
(id.to_owned(), code.clone())
})
.collect()
.collect();
found.sort();
found
};
assert!(small(1.24).is_empty());
let mut junctions = small(1.25);
junctions.sort();
assert_eq!(junctions, ["c7-t1", "l6-s1", "t18-l1"]);
assert_eq!(small(1.51).len(), 3);
assert_eq!(small(1.52).len(), 13, "every point, the zones still shown");
let pair = |id: &str, code: &str| (id.to_owned(), code.to_owned());
assert!(small(1.23).is_empty());
assert_eq!(small(1.24), [pair("caudal", THIN)]);
let (_, failures) = judged(&text, &[(HORSE_ID, &scaled_horse(1.24))]);
assert_eq!(
failures,
[THIN_FAILURE],
"the interior alone, never a rules failure"
);
assert_eq!(
small(1.25),
[
pair("c7-t1", TOO_SMALL),
pair("caudal", THIN),
pair("l6-s1", TOO_SMALL),
pair("t18-l1", TOO_SMALL),
]
);
assert_eq!(small(1.51).len(), 4);
let past = small(1.52);
assert_eq!(past.len(), 14, "every point and the caudal zone");
assert_eq!(past.iter().filter(|(_, code)| code == THIN).count(), 1);
}
/// A point shows its visible disc, `2 × max(2, r − 12)`, never its transparent hitbox; at
@@ -381,3 +405,152 @@ fn path_numbers_past_the_frame_magnitude_are_refused() {
assert_eq!(main(d), [OUT_OF_FRAME], "{d}");
}
}
/// The last MEDIUM (owner brief 2026-11-01, zone without interior): a polygon or a path must fill
/// a disc of 4 px on the smallest preview, its stroke left out. A frame of 286 × 310 units shows
/// one unit per CSS px on the main view. Each shape passes the bounds rule (it was accepted
/// before this rule) and is now refused.
#[test]
fn shapes_without_a_usable_interior_are_refused() {
let phone = "0 0 286 310";
let hostile = [
// A path drawn forth and back: winding 0 everywhere.
path("M20 20L200 200L20 20"),
path("M20 20L200 20L200 200L200 20Z"),
// The same square twice, in opposite directions: winding 0 under nonzero.
path("M20 20h100v100h-100zM20 20v100h100v-100z"),
// A near-flat polygon on the diagonal, 1 px thick, 180 px of bounds.
json!({ "type": "polygon", "points": [[20, 20], [200, 200], [200, 198.6]] }),
// A cubic and an arc travelled there and back.
path("M20 150C60 20 160 20 200 150C160 20 60 20 20 150Z"),
path("M20 150A90 90 0 0 1 200 150A90 90 0 0 0 20 150Z"),
// A flat ellipse turned 45°: 2 px thick, 127 px of bounds.
path("M50 50A127 1 45 0 1 230 230A127 1 45 0 1 50 50Z"),
// An L whose arms are 3.3 px wide: its widest disc, at the elbow, is 3.87 px.
json!({ "type": "polygon", "points": [[20, 20], [80, 20], [80, 23.3], [23.3, 23.3], [23.3, 80], [20, 80]] }),
];
for geometry in hostile {
let found = on_main(geometry.clone(), phone);
assert_eq!(codes(&found), [THIN], "{geometry}");
assert!(found.1.iter().any(|f| f == THIN_FAILURE), "{:?}", found.1);
}
}
/// Small shapes that fill: a 4.5 px tall triangle, a disc of 6 px drawn with two arcs, a cubic
/// lens, the L with 3.6 px arms (4.22 px at the elbow), a pentagram whose centre has winding 2
/// (the layer fills nonzero: 6.18 px; under evenodd only a tip would hold 3.26 px).
#[test]
fn small_shapes_that_fill_are_accepted() {
let phone = "0 0 286 310";
let legitimate = [
json!({ "type": "polygon", "points": [[20, 20], [200, 20], [110, 24.5]] }),
path("M100 100a3 3 0 1 0 6 0a3 3 0 1 0 -6 0Z"),
path("M20 100C40 90 60 90 80 100C60 110 40 110 20 100Z"),
json!({ "type": "polygon", "points": [[20, 20], [80, 20], [80, 23.6], [23.6, 23.6], [23.6, 80], [20, 80]] }),
json!({ "type": "polygon", "points": star(100.0, 100.0, 10.0) }),
];
for geometry in legitimate {
assert!(
codes(&on_main(geometry.clone(), phone)).is_empty(),
"{geometry}"
);
}
}
fn star(cx: f64, cy: f64, r: f64) -> Vec<[f64; 2]> {
(0..5)
.map(|i| {
let angle =
-std::f64::consts::FRAC_PI_2 + f64::from(i * 2) * std::f64::consts::TAU / 5.0;
[cx + r * angle.cos(), cy + r * angle.sin()]
})
.collect()
}
/// The threshold, on a shape whose widest disc is off its bounds' centre: an L with arms `w`
/// wide holds a disc of `2√2 w / (1 + √2)` at its elbow, a sharp peak the search approaches
/// from below. In doubt it refuses: measured, the first L accepted holds 4.026 px.
#[test]
fn the_interior_threshold_holds_at_its_edge() {
let elbow = |w: f64| {
let shape = json!({ "type": "polygon", "points": [[20, 20], [80, 20], [80, 20.0 + w], [20.0 + w, 20.0 + w], [20.0 + w, 80], [20, 80]] });
codes(&on_main(shape, "0 0 286 310"))
};
let diameter = |w: f64| 2.0 * std::f64::consts::SQRT_2 * w / (1.0 + std::f64::consts::SQRT_2);
assert!((diameter(3.44) - 4.030).abs() < 1e-3);
assert!(elbow(3.44).is_empty(), "4.030 px");
assert_eq!(elbow(3.43), [THIN], "4.019 px, in the doubt band");
assert_eq!(elbow(3.41), [THIN], "3.995 px");
}
/// Extreme frames and scales: the measure follows the projection, not the units. The same L at
/// a tenth of the scale, near the offset limit, and in a one-unit frame.
#[test]
fn the_interior_follows_the_projection() {
let l = |x: f64, y: f64, unit: f64, w: f64| {
let p = |a: f64, b: f64| [x + a * unit, y + b * unit];
json!({ "type": "polygon", "points": [p(0.0, 0.0), p(60.0, 0.0), p(60.0, w), p(w, w), p(w, 60.0), p(0.0, 60.0)] })
};
// Ten units per px.
assert!(codes(&on_main(l(200.0, 200.0, 10.0, 3.6), "0 0 2860 3100")).is_empty());
assert_eq!(
codes(&on_main(l(200.0, 200.0, 10.0, 3.3), "0 0 2860 3100")),
[THIN]
);
// The far edge at 256 spans (`MAX_FRAME_OFFSET_RATIO`): 2 860 units across, 0.1 px each.
let near = MAX_FRAME_OFFSET_RATIO * 2860.0 - 2860.0;
let frame = format!("{near} 0 2860 3100");
assert!(codes(&on_main(l(near + 200.0, 200.0, 10.0, 3.6), &frame)).is_empty());
assert_eq!(
codes(&on_main(l(near + 200.0, 200.0, 10.0, 3.3), &frame)),
[THIN]
);
// A one-unit frame: 286 px per unit.
let unit = 1.0 / 286.0;
assert!(codes(&on_main(l(0.1, 0.1, unit, 3.6), "0 0 1 1.0839")).is_empty());
assert_eq!(
codes(&on_main(l(0.1, 0.1, unit, 3.3), "0 0 1 1.0839")),
[THIN]
);
}
/// A drawing scaled inside never changes the interior: the markers are drawn in the frame.
#[test]
fn drawing_transforms_never_change_the_interior() {
let mut doc: Value = serde_json::from_str(&document()).unwrap();
doc["annotations"][0]["geometry"] = path("M20 20L200 200L20 20");
let scaled = OPEN.replace("0 0 10 10", "0 0 286 310")
+ "<g transform=\"scale(1000)\"><path d=\"M0 0h10v10z\"/></g></svg>";
let plain = OPEN.to_owned() + "<path d=\"M0 0h1\"/></svg>";
let (issues, _) = judged(
&doc.to_string(),
&[(MAIN_ASSET, &scaled), (DETAIL_ASSET, &plain)],
);
assert_eq!(
issues,
[(THIN.to_owned(), "annotations[0].geometry".to_owned())]
);
}
/// Over the measure's caps the shape is refused, never accepted: a disc drawn with 5 000 vertices.
#[test]
fn a_shape_too_complex_to_measure_is_refused() {
let ring = |count: u32| {
let points: Vec<[f64; 2]> = (0..count)
.map(|i| {
let angle = f64::from(i) * std::f64::consts::TAU / f64::from(count);
[143.0 + 100.0 * angle.cos(), 155.0 + 100.0 * angle.sin()]
})
.collect();
json!({ "type": "polygon", "points": points })
};
assert!(codes(&on_main(ring(4096), "0 0 286 310")).is_empty());
assert_eq!(codes(&on_main(ring(4097), "0 0 286 310")), [THIN]);
// The same cap on a path's outline, its curves' chords counted.
let square = |sides: usize| format!("M40 40{}h100v100h-100Z", "h0.001".repeat(sides));
assert_eq!(
codes(&on_main(path(&square(4092)), "0 0 286 310")),
Vec::<String>::new()
);
assert_eq!(codes(&on_main(path(&square(4093)), "0 0 286 310")), [THIN]);
}
+10 -1
View File
@@ -96,7 +96,16 @@ draw faithfully (edges within 2²⁰, spans from 1 unit, aspect at most
every annotation must show at least 4 CSS px on the smallest preview, the
editor at 320 × 568 (`verification.validation.marker_too_small`): a frame
blown up with its drawing scaled back keeps the drawing and shrinks every
marker, refused.
marker, refused. A zone or a trigger drawn as a polygon or a path must also
fill a disc of 4 CSS px on that preview, under the `nonzero` rule the layer
fills with (it writes no `fill-rule`, and none reaches it), its stroke left out
(`verification.validation.marker_interior_too_small`, owner brief 2026-11-01):
an outline drawn forth and back, the same loop twice in opposite directions, or
a near-flat shape on a diagonal fills no point a tap can reach, refused. The
measure is conservative (a disc crossing no edge, curves cut into chords whose
deviation is taken off) and refuses in doubt; a point painted over a zone takes
the taps on its disc, which the measure does not count (known limitation,
RUST.md §12.14).
The editor canvas is inlined in the page, where `#id` resolves against the
whole document. Since V1-2.2 (owner decision 2026-10-29) the core writes
+10 -1
View File
@@ -123,7 +123,16 @@ suite needs Docker in the runner for the sandbox.
100.9 left of it; Chromium keeps the fraction on a click, rounds a tap), so a
real press keeps 1.5 px of margin from any edge it tests; below that margin
the spec asks the browser's own hit test (`elementFromPoint`) at the exact
point. Firefox, WebKit
point. `e2e/ui/interior-clicks.spec.ts` runs on the same six projects
(V1-2.2, the interior rule): the core's probe cases
(`e2e/fixtures/interior-probe.json`, generated and drift-checked by
`crates/core/tests/interior_probe.rs`, `MAKE_INTERIOR_PROBE=1` rewrites it) in
the phone preview's 286 × 310 box (harness `e2e/harness/interior.{html,ts}`,
dev server only), then the equine zones in the canvas harness. Chromium's touch
adjustment gives a point the taps up to about 10 px around its disc
(measured 2026-11-01, `chromium-320` and `chromium-375`; WebKit 375 does
not), so the real press on an equine zone goes where its fill lies farthest
from every disc. 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
+69
View File
@@ -4342,3 +4342,72 @@ security review measured its consequence (MEDIUM, open, owner decision): a zone
(an outline traced twice in opposite directions) or a near-collinear polygon passes the 4 px rule, paints no interior
and is hit only on its 2-unit stroke (0.28 CSS px on the equine phone scale), in the three engines. Closing it needs a
filled-area measure (nonzero rule) or a « zone without interior » issue.
### 12.14 The last MEDIUM: zone without interior (owner, 2026-11-01)
Brief « V1-2.2 : fermeture du dernier MEDIUM » on `de2dfb3`: the decisions of §12.13 confirmed (threshold, frame rule,
bounds, codes `too_small` / `marker_too_small`, isolation, canvas passes, PDF order and bytes, R3 transforms, R4.1
manifest, the five former `fixme`); a zone without a usable filled interior refused by the verifier, in the core.
**Rule** (`anatomy::interior`, called by `frame::annotation_placement` after the bounds rule, so by the verdict and the
preview): a polygon or a path annotation (zone or trigger) must fill a disc of `MIN_VISIBLE_PX` 4 CSS px across on the
smallest preview (§12.13: main 286 × 310, detail 254 × 191, `xMidYMid meet`). Circles keep their exact disc measure.
| Part | What and why | Where |
|---|---|---|
| Fill rule | `nonzero` (`LAYER_FILL_RULE`): the layer writes no `fill-rule`, the composition root carries none, the drawing's sits in its own group (§12.12). The measure takes either rule; `evenodd` is tested, never used by the layer | `interior::FillRule` |
| Stroke | never counted: the measure reads the fill alone, whatever the shape's `pointer-events` (`all` on zones and triggers, its 2-unit stroke taken by the browser too) | |
| Outline | a polygon's points; a path read by the one SVG path reader (`path::path_outline`, same grammar and `±2²⁰` bound as `path_bounds`), each subpath closed by the fill, a lone moveto adding nothing; cubics, quadratics and arcs cut into chords: over a parameter step `h` a chord departs from its curve by at most `K h² / 8`, `K` bounding the second derivative (cubic `6 max‖Δ²‖`, quadratic `2‖Δ²‖`, arc `max(rx, ry) × sweep²`, the radii as scaled to reach the endpoint); chords asked within 0.05 px (`INTERIOR_TOLERANCE_PX`), at most `MAX_CURVE_CHORDS` 64 per curve, the largest deviation recorded | `path::Outline` |
| Measure | the widest disc whose centre the rule puts inside and every edge (closing edges included) at least the radius away: the disc crosses no edge, so all of it has the centre's winding number; the deviation taken off the radius. Conservative: a nonzero fill running on past an inner edge is not counted (pentagram: 3.09 measured, 3.82 filled) | `interior::widest_disc` |
| Search | polylabel's subdivision: square cells from one covering the outline, a cell's best centre at most its centre's radius plus its half diagonal, the most promising cell cut first (a max-heap ordered by `total_cmp`), cells below 0.05 px never cut; deterministic. Refuses in doubt: measured, the first L accepted at its elbow holds 4.026 px | |
| Caps | 4 096 outline vertices (`MAX_OUTLINE_VERTICES`), 4 096 cells per shape, one budget of `2²⁵` edge distances per sheet (`MAX_INTERIOR_WORK`, 0.35 s natively at 8 192 edges × 4 096 cells; the equine takes about 10⁵): a shape over them is refused, never accepted | `interior::Budget` |
| Refusal | issue `annotation.geometry.interior_too_small` (« fills no interior wide enough to tap », or « too complex for the interior measure »), verdict `verification.validation.marker_interior_too_small` after `marker_too_small`, never a rules failure; the document never rewritten | `report.rs`, `verdict.rs` |
Threshold, measured before freezing (equine draft, 320 × 568, widest disc across): caudal 4.951 px, sacral 11.30,
thoracic 11.47, cervical 12.17, lumbar 14.15, head trigger 29.13. 4 px keeps the approved threshold of the points (a point
shows a 4 px disc, a zone must hold one) and refuses no equine shape; the caudal zone now falls first when the horse is
scaled, past × 1.2378 (4.951 / 4), before the junctions (× 1.2414). Above 4.95 px the threshold would refuse the
validated equine; below, a tap target smaller than the points'.
| Proof | Result |
|---|---|
| `sheet_marker_visibility::shapes_without_a_usable_interior_are_refused` | each accepted before this rule (bounds pass): a path forth and back, a triangle traced back on itself, the same square twice in opposite directions, a 1 px diagonal sliver, a cubic and an arc travelled there and back, a 2 px ellipse turned 45°, an L of 3.3 px arms (3.87 px): `interior_too_small`, `marker_interior_too_small` |
| `small_shapes_that_fill_are_accepted` | a 4.5 px tall triangle, a 6 px disc of two arcs, a cubic lens, an L of 3.6 px arms (4.22 px), a pentagram of winding 2 (6.18 px; 3.26 under evenodd) |
| `the_interior_threshold_holds_at_its_edge` | L at 4.030 px accepted, 4.019 (doubt band) and 3.995 refused |
| `the_interior_follows_the_projection` | the same L at ten units per px, at the offset limit (256 spans), in a one-unit frame (286 px per unit) |
| `drawing_transforms_never_change_the_interior`, `a_shape_too_complex_to_measure_is_refused` | a drawing scaled × 1 000 changes nothing; 4 096 vertices measured, 4 097 refused (polygon and path) |
| equine | `the_equine_draft_shows_every_marker_on_the_phone_preview` passes; `the_equine_threshold_falls_on_the_caudal_zone_then_the_junctions`: × 1.235 accepted, × 1.24 the caudal zone alone (failures `[marker_interior_too_small]`), × 1.25 with the three junctions |
| `interior` unit tests | square, pentagram under both rules, forth and back, two opposite loops, deviation taken off, stop and floor, budget shared and spent, 60 random polygons (self-intersecting included) under both rules: never wider than a dense grid, every rim point filled |
| `path` unit tests | 300 random cubics, quadratics and arcs: every curve point within the recorded deviation of its chords, the deviation within 0.05 unless capped (arcs whose radii the endpoints scale up); closepath restarts at the subpath start; vertex cap |
Browsers (`apps/app/e2e/ui/interior-clicks.spec.ts`, the six click projects: Chromium 1280, 375 and 320 touch, Firefox
1280, WebKit 1280 and 375 touch; 90 passed, and `canvas-clicks.spec.ts` 99 unchanged). The probe
(`e2e/fixtures/interior-probe.json`, written and drift-checked by `tests/interior_probe.rs`) gives 14 shapes in the
preview's 286 × 310 box (one unit per CSS px) with the core's verdict and widest disc. For each, the browser's own fill
(`pointer-events="fill"`, stroke out) is sampled every 0.25 px and its widest disc taken by an exact distance transform:
the core never claims more than the browser fills (at most 0.5 px under it); the 8 refused fill no 4 px disc in any
engine; the 6 accepted take a real click or tap at the core's centre and the hit test at 32 points of 90 % of its radius,
fill only and as shipped. A drawing root `fill-rule="evenodd"` leaves the pentagram filled at its centre (isolation).
Then the equine shapes in the canvas: the core's disc hit test-clear (samples under a point's disc aside, at most a
quarter), and a real press where the fill lies farthest from every disc records the zone.
Chromium's touch adjustment, measured (tool `.claude/audits/2026-11-01-v1-2-2-interior-tools/`, taps every 2 px of each
equine zone's own hit area, 400 ms apart): a tap up to about 10 px around a point's disc goes to the point on
`chromium-320` and `chromium-375`, not on `webkit-375`. Taps recorded as the zone at 320 px: caudal 18/21, sacral 51/67,
lumbar 87/104, thoracic 72/97, cervical 195/195, trigger 278/284 (the rest to the neighbouring junctions and points, or to
nothing at the edges); WebKit 375: 91 to 99 %. Every equine zone keeps a tappable interior; near a point, Chromium's
targeting goes to the point, a browser behaviour the measure does not model (no selection redesign in V1-2.2).
Known limitation (owner, 2026-11-01, LOW accepted): a visible disc covering another marker entirely, or the only
interior of a zone, takes its taps; no rule refuses it. The human review identifies overlapping markers before a sheet
is published; no proof here claims that every marker is individually selectable when two overlap entirely. The arc
rotation reduced in `f32` by browsers (sub-pixel, §12.13) stays bounded by the `2²⁰` number bound, its tests kept.
Mutations (`.claude/audits/2026-11-01-v1-2-2-mutations-interior.py`): 24 killed, Z22 (the floor prune removed) survives
as equivalent, a cell that cannot reach the floor never holding an accepted disc; S1, S8 and F16 of the previous scripts,
whose anchors moved, re-anchored and killed. Module 579 180 B gzip -9 (+4 946 B, budget 600 000, margin 20 820 B).
Ignored cargo tests: the three are one test, `pdf_serialize::l_report_with_real_rasters_costs_what_it_costs`, counted
once per cargo run whose features build `pdf_serialize` (workspace, `cli`, `ts,pdf-read,pdf-write`). A timing print for
§10.7, 40 s in debug; run on request in release (2026-11-01: passed, 120 views, 46.5 MB, 5.2 s). The L report's export
itself is covered unignored (`pdf_budget`); it masks no required scenario.
@@ -1048,6 +1048,7 @@ Four stages, each a superset of the previous:
| Every reachable drawing present, size and sha256 equal to its row, read without removal, in the stored form of §9.2 | yes | | | `verification.integrity.*` |
| Every annotation entirely inside the frame of its view, edges included: the view's `view_box`, else the `viewBox` of the drawing it draws, read as a browser reads it (four numbers, positive width and height) and usable within the range rules browsers draw faithfully (owner brief 2026-11-01: edges within 2²⁰, spans from 1 unit, aspect at most 100, farthest edge at most 256 smaller spans); curves and arcs measured on their shape; path data a browser would not read whole refused; a view drawn on a clean drawing without either has no frame. Measured on the views whose drawing reads clean; the document is never rewritten (owner brief 2026-10-30, RUST.md §12.11) | yes | | | `verification.validation.out_of_frame` (issues `annotation.geometry.out_of_frame`, `view.frame.unknown`) |
| Every annotation in frame shows at least 4 CSS px on the smallest preview, the editor at 320 × 568 (main view box 286 × 310, detail view box 254 × 191, `xMidYMid meet`): a point's visible disc (`2 × max(2, r − 12)`), a trigger circle's diameter, a polygon's or a path's smaller side (curves and arcs on their shape). Same views, same frame; the document is never rewritten (owner brief 2026-11-01, RUST.md §12.13) | yes | | | `verification.validation.marker_too_small` (issue `annotation.geometry.too_small`) |
| Every polygon or path annotation in frame fills a disc of 4 CSS px on the same preview: under the `nonzero` rule the layer fills with, its stroke left out, a centre inside the fill at least the radius from every edge (closing edges included), curves and arcs cut into chords whose deviation is taken off; measured within `interior::MAX_OUTLINE_VERTICES` 4 096 vertices and one budget of `2²⁵` edge distances per sheet, refused past them; refused in doubt (owner brief « fermeture du dernier MEDIUM » 2026-11-01, RUST.md §12.14) | yes | | | `verification.validation.marker_interior_too_small` (issue `annotation.geometry.interior_too_small`) |
| Fingerprint computed | yes | | | `verification.integrity.fingerprint` |
| Verdict passed, on the current revision | | yes | yes | `verdict.missing`, `verdict.failed`, `verdict.stale` |
| No `to_confirm` element (D2) | | yes | yes | `publish.to_confirm.open` |