From 3d709ec0151d8dece43a19a570bfebd3fd246aab Mon Sep 17 00:00:00 2001 From: IliesAllali Date: Sun, 18 Oct 2026 19:33:38 +0200 Subject: [PATCH 1/3] Renvoi seulement si le fil croise une autre famille MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Une filiation vers un enfant placé sous l'autre lignée devenait un renvoi (pastilles) dès que l'écart union → enfant dépassait 360 px, même quand le fil ne croisait personne. Le critère est maintenant géométrique : le fil file sur la ligne de la fratrie entre l'aplomb de l'union et l'enfant ; il ne devient renvoi que si une personne d'une autre famille se trouve sur cette ligne. Frères et sœurs et conjoint(e)s de l'enfant ne comptent pas. Tests : cas à fratrie voisine (fil conservé), et filCroiseAutreFamille sur des nœuds synthétiques (autre famille, fratrie seule, conjoint, autre génération). Co-Authored-By: Claude Haiku 5.5 --- frontend/src/components/galaxy/blockLayout.js | 33 +++++++++++-- .../src/components/galaxy/blockLayout.test.js | 49 ++++++++++++++++++- frontend/src/components/galaxy/constants.js | 2 - 3 files changed, 76 insertions(+), 8 deletions(-) diff --git a/frontend/src/components/galaxy/blockLayout.js b/frontend/src/components/galaxy/blockLayout.js index 93b4133..c20275b 100644 --- a/frontend/src/components/galaxy/blockLayout.js +++ b/frontend/src/components/galaxy/blockLayout.js @@ -1,5 +1,4 @@ import { computeLayout, componentOrderPerGen, chainGap } from './elkLayout' -import { RENVOI_MIN_DX } from './constants' // ============================================================ // Layout par blocs familiaux (Reingold-Tilford adapté aux couples) @@ -27,6 +26,18 @@ import { RENVOI_MIN_DX } from './constants' const NODE_SPACING = 30 const FAMILY_GAP = 60 +// Le fil d'une filiation union → enfant : une personne d'une autre famille, sur la ligne de l'enfant, +// entre l'aplomb de l'union et l'enfant, est croisée. Frères et sœurs et conjoint(e)s de l'enfant ne comptent pas. +export function filCroiseAutreFamille(nodes, childrenOfUnion, spouseKeysOf, u, c) { + const byIdLocal = new Map(nodes.map(n => [n.id, n])) + const kid = byIdLocal.get(c) + const cx = (id) => byIdLocal.get(id).x + byIdLocal.get(id).width / 2 + const excluded = new Set([c, ...(childrenOfUnion.get(u) || []), ...(spouseKeysOf.get(c) || [])]) + const lo = Math.min(cx(u), cx(c)), hi = Math.max(cx(u), cx(c)) + return nodes.some(n => n._type === 'person' && n._generation === kid._generation && !excluded.has(n.id) + && n.x + n.width > lo && n.x < hi) +} + export function computeBlockLayout(graphData = null) { const result = computeLayout(graphData) const nodes = result.children @@ -209,13 +220,25 @@ export function computeBlockLayout(graphData = null) { for (const n of nodes) if (pos.has(n.id)) minX = Math.min(minX, pos.get(n.id)) for (const n of nodes) if (pos.has(n.id)) n.x = pos.get(n.id) - minX - // Arête longue vers un enfant placé sous l'autre lignée : dessinée en renvoi (voir drawFiliations) - // Plusieurs renvois sous la même union : pastilles empilées (_renvoiIndex) - const centerX = (id) => byId.get(id).x + byId.get(id).width / 2 + // Arête vers un enfant placé sous l'autre lignée : renvoi (voir drawFiliations) seulement si le fil + // croise une autre famille. Plusieurs renvois sous la même union : pastilles empilées (_renvoiIndex) + // Le fil descend de l'union puis file sur la ligne de la fratrie jusqu'à l'enfant (traceBus) : + // il ne traverse une autre famille que si une personne de cette famille se trouve sur cette ligne, + // entre l'aplomb de l'union et l'enfant. Frères et sœurs et conjoint(e)s de l'enfant ne comptent pas. + const spouseKeysOf = new Map() + for (const n of nodes) { + if (n._type !== 'union' || !n._data?.p1Key || !n._data?.p2Key) continue + const { p1Key, p2Key } = n._data + if (!spouseKeysOf.has(p1Key)) spouseKeysOf.set(p1Key, new Set()) + if (!spouseKeysOf.has(p2Key)) spouseKeysOf.set(p2Key, new Set()) + spouseKeysOf.get(p1Key).add(p2Key) + spouseKeysOf.get(p2Key).add(p1Key) + } + const crossesOtherFamily = (u, c) => filCroiseAutreFamille(nodes, childrenOfUnion, spouseKeysOf, u, c) const renvoisByUnion = new Map() for (const e of result.edges) { const u = e.sources[0], c = e.targets[0] - if (!externalEdges.has(`${u}>${c}`) || Math.abs(centerX(u) - centerX(c)) <= RENVOI_MIN_DX) continue + if (!externalEdges.has(`${u}>${c}`) || !crossesOtherFamily(u, c)) continue e._renvoi = true e._renvoiIndex = renvoisByUnion.get(u) || 0 renvoisByUnion.set(u, e._renvoiIndex + 1) diff --git a/frontend/src/components/galaxy/blockLayout.test.js b/frontend/src/components/galaxy/blockLayout.test.js index 5120a6a..80e1148 100644 --- a/frontend/src/components/galaxy/blockLayout.test.js +++ b/frontend/src/components/galaxy/blockLayout.test.js @@ -1,5 +1,5 @@ import { describe, it, expect } from 'vitest' -import { computeBlockLayout } from './blockLayout' +import { computeBlockLayout, filCroiseAutreFamille } from './blockLayout' import { COMPACT_W, PERSON_W } from './constants' const person = (id) => ({ id, firstName: id, lastName: '' }) @@ -60,3 +60,50 @@ describe('computeBlockLayout, ordre de la fratrie', () => { expect(order(graphWith([1, 1, 1]))).toEqual(['a', 'b', 'c']) }) }) + +describe('computeBlockLayout, renvoi seulement si le fil croise une autre famille', () => { + // Structure type : l'enfant (P) a sa fratrie à côté, son conjoint (Z) est dans la lignée de l'autre parent + // Jacqueline + Roger ont 6 enfants, dont Marie, en couple avec Philippe ; Marcel + Yvette ont 5 enfants, dont Philippe + const graph = { + persons: ['jac', 'rog', 'marie', 'philippe', 'anais', 'greg', 'marcel', 'yvette', 'severine', 'isabelle', 'laurent', 'stephane', 'k1', 'k2', 'k3', 'k4', 'k5'].map(person), + unions: [union('uJR', 'jac', 'rog'), union('uMP', 'marie', 'philippe'), union('uMY', 'marcel', 'yvette')], + filiations: [ + ...['k1', 'k2', 'k3', 'k4', 'k5'].map((k, i) => fil(`f${k}`, k, 'uJR', i + 1)), fil('fmarie', 'marie', 'uJR', 6), + fil('fa', 'anais', 'uMP'), fil('fg', 'greg', 'uMP'), + fil('fs', 'severine', 'uMY', 1), fil('fi', 'isabelle', 'uMY', 2), fil('fl', 'laurent', 'uMY', 3), + fil('fst', 'stephane', 'uMY', 4), fil('fp', 'philippe', 'uMY', 5), + ], + } + + it('garde le fil vers Philippe quand la fratrie de son autre famille est à côté de lui', () => { + const { edges } = computeBlockLayout(graph) + expect(edges.find(e => e.sources[0] === 'u-uMY' && e.targets[0] === 'p-philippe')._renvoi).toBeUndefined() + }) +}) + +describe('filCroiseAutreFamille', () => { + // Ligne d'une génération : union u (aplomb x=0 à 120), enfant c en x=600 + const at = (id, x, type = 'person', gen = 1) => ({ id, x, width: 120, _type: type, _generation: gen }) + const base = () => [at('u', 0, 'union', 0), at('c', 600), at('sib', 300), at('spouse', 700), at('other', 400)] + const childrenOfUnion = new Map([['u', ['c', 'sib']]]) + const spouseKeysOf = new Map([['c', new Set(['spouse'])]]) + + it('croise quand une personne d\'une autre famille est entre l\'union et l\'enfant', () => { + expect(filCroiseAutreFamille(base(), childrenOfUnion, spouseKeysOf, 'u', 'c')).toBe(true) + }) + + it('ne croise pas quand seuls les frères et sœurs sont entre l\'union et l\'enfant', () => { + const nodes = base().filter(n => n.id !== 'other') + expect(filCroiseAutreFamille(nodes, childrenOfUnion, spouseKeysOf, 'u', 'c')).toBe(false) + }) + + it('ne croise pas pour le conjoint de l\'enfant placé du côté de l\'enfant', () => { + const nodes = base().filter(n => n.id !== 'other').map(n => n.id === 'spouse' ? { ...n, x: 300 } : n) + expect(filCroiseAutreFamille(nodes, childrenOfUnion, spouseKeysOf, 'u', 'c')).toBe(false) + }) + + it('ignore une personne d\'une autre génération sur la même abscisse', () => { + const nodes = base().filter(n => n.id !== 'other').concat(at('x', 400, 'person', 2)) + expect(filCroiseAutreFamille(nodes, childrenOfUnion, spouseKeysOf, 'u', 'c')).toBe(false) + }) +}) diff --git a/frontend/src/components/galaxy/constants.js b/frontend/src/components/galaxy/constants.js index b4c161f..5a90fdc 100644 --- a/frontend/src/components/galaxy/constants.js +++ b/frontend/src/components/galaxy/constants.js @@ -16,8 +16,6 @@ export const COMPACT_SCALE = 0.6 export const COMPACT_R = PERSON_R * COMPACT_SCALE export const COMPACT_W = 40 export const COMPACT_JOIN_GAP = -18 -// Filiation qui traverse l'arbre (enfant placé sous l'autre lignée) : renvoi cliquable au lieu du trait -export const RENVOI_MIN_DX = 360 export const MAX_ORBIT_MEDIAS = 3 export const ORBIT_RADIUS = 55 export const ORBIT_MEDIA_SIZE = 22 From d58b7b779c58b8fbf9f5217d5e5b699dd03d93a5 Mon Sep 17 00:00:00 2001 From: IliesAllali Date: Sun, 18 Oct 2026 19:45:20 +0200 Subject: [PATCH 2/3] Filiations : une seule trajectoire par fratrie MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Chaque enfant avait son propre chemin depuis l'union, avec un rayon de virage propre : sous une union nombreuse, 3 ou 4 brins se séparaient juste sous le point d'union. Le tracé est maintenant un tronc unique, puis une barre de fratrie qui distribue vers chaque enfant ; le rayon des virages est commun à chaque côté, et tout part dans un seul stroke (pas de brins doublés en alpha). Un enfant presque sous l'union descend de la barre, sans second brin depuis l'union. Le chemin en surbrillance (path highlight) reste tracé enfant par enfant. Vérifié à l'écran sur un arbre de test à 6 enfants (avant/après dans _bmad-output/parenthese/renvoi/faisceau-*.png). Co-Authored-By: Claude Haiku 5.5 --- frontend/src/components/galaxy/renderers.js | 64 +++++++++++++++++---- 1 file changed, 53 insertions(+), 11 deletions(-) diff --git a/frontend/src/components/galaxy/renderers.js b/frontend/src/components/galaxy/renderers.js index 25b52ce..a582d79 100644 --- a/frontend/src/components/galaxy/renderers.js +++ b/frontend/src/components/galaxy/renderers.js @@ -126,6 +126,39 @@ function traceBus(ctx, sx, sy, by, ex, ey) { ctx.stroke() } +// Une union, toute sa fratrie : une seule trajectoire (un tronc, une accolade, un trait par enfant). +// Un chemin par enfant aurait un rayon de virage propre, donc des brins qui se séparent sous l'union. +// Le rayon est commun à chaque côté (le plus petit écart du côté), et le tout part dans un seul stroke +// pour que les parties superposées ne s'additionnent pas en alpha. +function traceSibship(ctx, sourceId, sourcePos, items) { + const sx = sourcePos.cx, sy = sourcePos.cy + const by = busY(sourceId, sy) + const drop = Math.min(by - sy, 64) + const turnFor = (dir) => { + let t = BUS_TURN + for (const it of items) { + const dx = it.cx - sx + if (Math.sign(dx) === dir && Math.abs(dx) >= BUS_STRAIGHT_DX) t = Math.min(t, Math.abs(dx) / 2) + } + return t + } + const turns = { '-1': turnFor(-1), '1': turnFor(1) } + ctx.beginPath() + for (const { cx: ex, cy: ey } of items) { + const dx = ex - sx + ctx.moveTo(sx, sy) + ctx.lineTo(sx, by - drop) + // Enfant presque sous l'union : descente droite depuis la barre, pas de second brin depuis l'union + if (Math.abs(dx) < BUS_STRAIGHT_DX) { ctx.lineTo(ex, by); ctx.lineTo(ex, ey); continue } + const dir = Math.sign(dx) + const turn = turns[dir] + ctx.quadraticCurveTo(sx, by, sx + dir * turn, by) + ctx.lineTo(ex - dir * turn, by) + ctx.quadraticCurveTo(ex, by, ex, ey) + } + ctx.stroke() +} + // Trace une filiation union → enfant. progress < 1 : entrée en fondu function traceFiliation(ctx, sourceId, sourcePos, targetPos, childR, progress) { const a = ctx.globalAlpha @@ -251,6 +284,7 @@ export function drawFiliations(ctx, edges, posMap, nodeMap, nodeRandomData, entr renvoiHitAreas.length = 0 renvoiPills.length = 0 if (!edges) return + const sibships = new Map() edges.forEach(edge => { const sourceId = edge.sources[0] @@ -271,7 +305,22 @@ export function drawFiliations(ctx, edges, posMap, nodeMap, nodeRandomData, entr const targetNode = nodeMap.get(targetId) const pType = edge._parentageType || 'biologique' + const childR = nodeRadius(targetNode) + if (edge._renvoi) { + ctx.globalAlpha = Math.min(1, edgeProgress * 1.5) + drawRenvoi(ctx, edge, sourcePos, targetPos, targetNode, childR, view) + ctx.globalAlpha = 1 + return + } + // Les enfants d'une même union (même type de filiation) forment une seule fratrie, tracée d'un coup + const key = `${sourceId}|${pType}` + if (!sibships.has(key)) sibships.set(key, { sourceId, sourcePos, pType, items: [], progress: 0 }) + const sib = sibships.get(key) + sib.items.push({ cx: targetPos.cx, cy: targetPos.cy - childR }) + sib.progress += edgeProgress + }) + for (const { sourceId, sourcePos, pType, items, progress } of sibships.values()) { if (pType === 'adoption') { ctx.setLineDash([8, 5]) ctx.strokeStyle = FIL.color @@ -284,19 +333,12 @@ export function drawFiliations(ctx, edges, posMap, nodeMap, nodeRandomData, entr } ctx.lineWidth = FIL.width ctx.lineCap = 'round' - ctx.globalAlpha = Math.min(1, edgeProgress * 1.5) - - const childR = nodeRadius(targetNode) - if (edge._renvoi) { - drawRenvoi(ctx, edge, sourcePos, targetPos, targetNode, childR, view) - ctx.globalAlpha = 1 - ctx.setLineDash([]) - return - } - traceFiliation(ctx, sourceId, sourcePos, targetPos, childR, edgeProgress) + const p = progress / items.length + ctx.globalAlpha = Math.min(1, p * 1.5) * p + traceSibship(ctx, sourceId, sourcePos, items) ctx.globalAlpha = 1 ctx.setLineDash([]) - }) + } } // ============================================================ From 9d9e375f582f980c9cbeaf4416e54f2ecee7cc75 Mon Sep 17 00:00:00 2001 From: IliesAllali Date: Sun, 18 Oct 2026 20:26:34 +0200 Subject: [PATCH 3/3] Filiations : accolade franche (forme A) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Remplace le virage quadratique par une accolade à coins arrondis de rayon fixe (24 px) : un tronc depuis l'union, une barre de fratrie, puis une descente vers chaque enfant. Un enfant à l'aplomb de l'union descend droit. Le chemin surligné (sélection, survol) passe par la même géométrie que la fratrie. Tests unitaires de traceSibship (un chemin et un stroke par fratrie, même géométrie pour un enfant seul, pas de virage à l'aplomb). Co-Authored-By: Claude Haiku 5.5 --- frontend/src/components/galaxy/renderers.js | 73 +++++-------------- .../src/components/galaxy/renderers.test.js | 38 ++++++++++ 2 files changed, 57 insertions(+), 54 deletions(-) create mode 100644 frontend/src/components/galaxy/renderers.test.js diff --git a/frontend/src/components/galaxy/renderers.js b/frontend/src/components/galaxy/renderers.js index a582d79..897fcb9 100644 --- a/frontend/src/components/galaxy/renderers.js +++ b/frontend/src/components/galaxy/renderers.js @@ -91,15 +91,14 @@ function computeCouplePoints(p1Pos, p2Pos, unionPos, p1R, p2R, nodeRandomData, s // Fil : terracotta clair, union en rond terracotta (le rond du logo). // Filiation en accolade souple : l'union descend vers une ligne // commune à la fratrie, chaque enfant s'en détache par une courbe. -// Les virages sont des quadratiques larges, pas des coins. +// Coins arrondis de rayon fixe (accolade franche, forme A). // ============================================================ export const FIL = { color: '#E3A590', width: 1.1, dot: '#D2694A', dotR: 2.6 } // Ligne de la fratrie : sous les prénoms et années des parents, au-dessus des enfants const BUS_DY = 100 -// Rayon horizontal des virages (plafonné à la moitié de l'écart union → enfant) -const BUS_TURN = 56 -// En dessous de cet écart union → enfant, pas de virage -const BUS_STRAIGHT_DX = 30 +// Accolade : coins arrondis de rayon fixe (forme A, choisie par Patch), écart minimal en dessous duquel l'enfant descend droit +const SIB_R = 24 +const SIB_STRAIGHT_DX = 12 function busY(sourceId, sy) { let h = 0 @@ -108,65 +107,29 @@ function busY(sourceId, sy) { return sy + BUS_DY + (Math.abs(h) % 3) * 4 } -function traceBus(ctx, sx, sy, by, ex, ey) { - const dx = ex - sx - ctx.beginPath() - ctx.moveTo(sx, sy) - // Enfant presque sous l'union (enfant unique, décalage aléatoire de quelques px) : trait direct, pas de S - if (Math.abs(dx) < BUS_STRAIGHT_DX) { ctx.lineTo(ex, ey); ctx.stroke(); return } - const dir = Math.sign(dx) - const turn = Math.min(BUS_TURN, Math.abs(dx) / 2) - // Descente de l'union, virage large vers la ligne de la fratrie - const drop = Math.min(by - sy, 64) - ctx.lineTo(sx, by - drop) - ctx.quadraticCurveTo(sx, by, sx + dir * turn, by) - // Ligne de la fratrie, puis courbe jusqu'au portrait de l'enfant - ctx.lineTo(ex - dir * turn, by) - ctx.quadraticCurveTo(ex, by, ex, ey) - ctx.stroke() -} - -// Une union, toute sa fratrie : une seule trajectoire (un tronc, une accolade, un trait par enfant). -// Un chemin par enfant aurait un rayon de virage propre, donc des brins qui se séparent sous l'union. -// Le rayon est commun à chaque côté (le plus petit écart du côté), et le tout part dans un seul stroke -// pour que les parties superposées ne s'additionnent pas en alpha. -function traceSibship(ctx, sourceId, sourcePos, items) { +// Une union, toute sa fratrie : un seul tracé. Tronc depuis l'union jusqu'à la barre, coins arrondis +// de même rayon à chaque jonction, puis descente vers chaque enfant. Chaque enfant a sa propre trajectoire +// (sur la même barre), donc le surlignage du chemin suit exactement la même géométrie. +export function traceSibship(ctx, sourceId, sourcePos, items) { const sx = sourcePos.cx, sy = sourcePos.cy const by = busY(sourceId, sy) - const drop = Math.min(by - sy, 64) - const turnFor = (dir) => { - let t = BUS_TURN - for (const it of items) { - const dx = it.cx - sx - if (Math.sign(dx) === dir && Math.abs(dx) >= BUS_STRAIGHT_DX) t = Math.min(t, Math.abs(dx) / 2) - } - return t - } - const turns = { '-1': turnFor(-1), '1': turnFor(1) } + const rr = Math.min(SIB_R, by - sy - 2) ctx.beginPath() for (const { cx: ex, cy: ey } of items) { const dx = ex - sx ctx.moveTo(sx, sy) - ctx.lineTo(sx, by - drop) - // Enfant presque sous l'union : descente droite depuis la barre, pas de second brin depuis l'union - if (Math.abs(dx) < BUS_STRAIGHT_DX) { ctx.lineTo(ex, by); ctx.lineTo(ex, ey); continue } + if (Math.abs(dx) < SIB_STRAIGHT_DX) { ctx.lineTo(sx, by); ctx.lineTo(ex, by); ctx.lineTo(ex, ey); continue } const dir = Math.sign(dx) - const turn = turns[dir] - ctx.quadraticCurveTo(sx, by, sx + dir * turn, by) - ctx.lineTo(ex - dir * turn, by) - ctx.quadraticCurveTo(ex, by, ex, ey) + const k = Math.min(rr, Math.abs(dx) / 2) + ctx.lineTo(sx, by - k) + ctx.arcTo(sx, by, sx + dir * k, by, k) + ctx.lineTo(ex - dir * k, by) + ctx.arcTo(ex, by, ex, ey, k) + ctx.lineTo(ex, ey) } ctx.stroke() } -// Trace une filiation union → enfant. progress < 1 : entrée en fondu -function traceFiliation(ctx, sourceId, sourcePos, targetPos, childR, progress) { - const a = ctx.globalAlpha - ctx.globalAlpha = a * progress - traceBus(ctx, sourcePos.cx, sourcePos.cy, busY(sourceId, sourcePos.cy), targetPos.cx, targetPos.cy - childR) - ctx.globalAlpha = a -} - // ============================================================ // Courbes de couple (Bézier) // ============================================================ @@ -411,7 +374,9 @@ export function drawPathHighlight(ctx, { ctx.lineCap = 'round' ctx.globalAlpha = 1 - traceFiliation(ctx, edge.sources[0], sourcePos, targetPos, childR, hp) + ctx.globalAlpha = hp + traceSibship(ctx, edge.sources[0], sourcePos, [{ cx: targetPos.cx, cy: targetPos.cy - childR }]) + ctx.globalAlpha = 1 }) } diff --git a/frontend/src/components/galaxy/renderers.test.js b/frontend/src/components/galaxy/renderers.test.js new file mode 100644 index 0000000..93ddbe0 --- /dev/null +++ b/frontend/src/components/galaxy/renderers.test.js @@ -0,0 +1,38 @@ +import { describe, it, expect } from 'vitest' +import { traceSibship } from './renderers' + +// Contexte canvas minimal qui enregistre les appels de tracé +const recorder = () => { + const calls = [] + const ctx = new Proxy({}, { get: (_, name) => (...args) => { calls.push([name, ...args]) } }) + return { ctx, calls, count: (n) => calls.filter(c => c[0] === n).length } +} +const src = { cx: 500, cy: 300 } + +describe('traceSibship (accolade franche)', () => { + it('trace toute la fratrie en un seul chemin et un seul stroke', () => { + const { ctx, count } = recorder() + traceSibship(ctx, 'u-1', src, [{ cx: 200, cy: 480 }, { cx: 420, cy: 480 }, { cx: 800, cy: 480 }]) + expect(count('beginPath')).toBe(1) + expect(count('stroke')).toBe(1) + expect(count('moveTo')).toBe(3) + }) + + it('un enfant seul rejoint la barre avec la même géométrie que dans la fratrie', () => { + const child = { cx: 800, cy: 480 } + const solo = recorder() + traceSibship(solo.ctx, 'u-1', src, [child]) + const group = recorder() + traceSibship(group.ctx, 'u-1', src, [child, { cx: 200, cy: 480 }]) + const soloArcs = solo.calls.filter(c => c[0] === 'arcTo') + const groupArcs = group.calls.filter(c => c[0] === 'arcTo').slice(0, 2) + expect(soloArcs.length).toBe(2) + expect(groupArcs).toEqual(soloArcs) + }) + + it('un enfant à l\'aplomb de l\'union descend droit, sans virage', () => { + const { ctx, count } = recorder() + traceSibship(ctx, 'u-1', src, [{ cx: 505, cy: 480 }]) + expect(count('arcTo')).toBe(0) + }) +})