flowsvg 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,58 @@
 # Changelog
 
+## Unreleased
+
+- Place the animated FlowSVG wordmark first in centered headers in both SDK READMEs. Use larger text inside a compact frame, a closely cropped 50 fps GIF, and a closed signal loop at the upper-right corner. Ship the shared GIF under `docs/images/` and rewrite relative Markdown and HTML image paths to the versioned npm CDN URL during release verification.
+
+## 0.2.0 - 2026-10-22
+
+### Timing and rendering changes
+
+- A beat with one flow now lasts for distance-based movement plus a 500 ms post-arrival interval, replacing authored `durationMs`. Movement targets 180 diagram units/second with a 400 ms minimum. Receiver paint fades in for 200 ms, holds for 100 ms, then automatic node/edge highlights fade out for 200 ms. Explicit highlights retain authored timing; reduced motion skips fades. Multi-flow and no-flow beats retain authored timing. Use the frozen public `Diagram.beats` schedule for effective boundaries and separate no-flow beats for longer reading.
+- Orthogonal routes use rounded bends, centered clear bridges, separate stable incoming tips and stroke-aware arrow approaches. Curved inputs also retain stable separate tips. SVG paths, markers, labels, bounds and hit testing share the same geometry.
+
+### Added
+
+- Browser GIF export through `flowsvg/export`, with snapshot inputs, range/speed/dimensions/captions, progress, cancellation, frame limits and an inline encoding worker. Optional player download controls work across Native, React, Vue and Web Component integrations; ordinary playback loads no encoder.
+- Node 20+ `flowsvg/node` and CLI for standalone offline HTML and Chromium-based GIF export. HTML can embed optional GIF controls. GIF tasks use explicitly prepared Chromium or a caller-owned browser. Exports clean up task resources; CLI publication is atomic and preserves existing files unless overwrite is explicit. Copyable versioned portable assets include licenses.
+- Opt-in live Loop playback and accessible Loop controls across integrations and portable HTML. Preserve elapsed remainder and speed at automatic wraps. GIF repetition remains independent.
+- Deterministic DOM-free `measureNodeContent` and public measurement types for fixed-width authoring across explicit content versions. Preserve diagnostics and caller inputs; reject unrepresentable heights with field-path `DiagramValidationError`.
+- Optional `viewport.fitHeight: { padding }` fits current painted geometry while retaining authored width and origin. Full-view SVG and playback fit height; GIF retains authored fixed dimensions and scale. Explicit focus retains authored viewport semantics.
+- Optional `flow.highlightParticipants: false` suppresses automatic endpoint paint while retaining explicit highlights, edge paint and moving dots/capsules.
+- Pill-shaped structured-content tags, reusable public `SelectControl`, opt-in compact controls, keyboard menus, refined control styles and responsive progress layout.
+
+### Fixed and verified
+
+- Reject asynchronous GIF worker startup errors during pending rasterization. Release export resources on errors, cancellation and player destruction, and permit subsequent exports.
+- Validate GIF options, effective captions and final encoded-frame limits before resource allocation. Preserve inherited state, range-end pictures and cumulative centisecond timing.
+- Preserve content diagnostics for large block collections and avoid fractional-origin false positives in graph-label height checks.
+- Keep SDK tests and release gates independent of showcase data. Verify cold packaging, file allowlists, DOM-free imports, strict consumer types, minimum framework versions, all four integrations and real offline HTML/GIF output through the installed tarball.
+
+## 0.1.1 - 2026-10-20
+
+- Adopted thin neutral node borders, gray edges and blue emphasis in both themes. Separate highlight fills from borders and flow markers, remove the node-label halo, and refresh README previews.
+
+- Expanded the quick-start document to a six-node order workflow with authorization, persistence, asynchronous events and reverse responses.
+
+- Added SDK-rendered previews beside the quick-start, structured-content, list, entity-graph and Facts timeline examples in both package READMEs.
+
+- Include the eight README preview images in the npm tarball. Source READMEs use relative image paths for local previews; the release verifier prepares staged README copies with versioned npm CDN URLs for public readers. Release verification requires every preview and rejects undeclared documentation assets.
+
+- Removed local build, source-layout and release instructions from the package READMEs; repository documentation retains the contributor workflow.
+
+- Completed bilingual module navigation, updated migrated test links, and consolidated architecture implementation and verification records.
+
+- Grouped React, Vue, and Web Component implementations under `src/adapters/` while keeping explicit root entries, shared Web Component registration identity, SSR-safe imports, lifecycle behavior, and cross-host integration tests. Updated nested release artifacts and consumer references.
+
+- Grouped the browser player implementation and its controls, accessibility, lifecycle, and SVG DOM modules under `src/browser/` while preserving the `flowsvg/browser` entry, lifecycle behavior, DOM-free imports, and public player contract. Updated browser tests and release allowlists for nested build output.
+
+- Moved shared hexadecimal color interpolation to the pure `src/core/color.ts` module. Timeline evaluation and diagram paint share the same runtime helper; content painting checks contrast without a timeline dependency.
+
+- Centralized edge routing, path sampling, distance queries, label anchors, hit testing, and SVG number formatting in `src/core/edge-geometry.ts` and `src/core/svg-number.ts` while preserving the existing public frames and SVG output.
+
+- Organized the platform-independent core into shared model, document validation and diagram orchestration modules. Preserved all public values/types, error identity and evaluation behavior; grouped core tests with their implementation.
+- Preserved nested JavaScript and declaration build output and replaced the release file pattern with an explicit module allowlist that rejects source, tests and unrelated files.
+
 ## 0.1.0 - 2026-10-17
 
 - Added a release CLI that runs type checks, SDK and release-script tests, tarball consumer verification, example builds and npm publication preview. Default to preview; require `--publish` for upload, and publish the exact verified tarball retained in `dist/releases/`.
@@ -9,7 +62,7 @@
 - Prepared the first npm release with repository metadata, public registry settings, bilingual package documentation, automatic prepack builds and prepublish type/test checks.
 - Verify packaging from a missing `dist`, every exported JavaScript/type/CSS target, the file allowlist, framework-free imports, strict consumer types and all four host lifecycles.
 
-- Renamed the package and SDK directory to `flowsvg` (流形). Player exports now use the `Flow` prefix: `FlowPlayer`, `FlowPlayerProps`, `FlowPlayerHandle`, `FlowPlayerElement`, `defineFlowPlayer()` and `FLOW_PLAYER_TAG`. The default element is `<flowsvg-player>`; CSS classes and control variables use `flowsvg-` and `--flowsvg-`. Imports, selectors and public API references must use the new names.
+- Renamed the package and SDK directory to `flowsvg`. Player exports now use the `Flow` prefix: `FlowPlayer`, `FlowPlayerProps`, `FlowPlayerHandle`, `FlowPlayerElement`, `defineFlowPlayer()` and `FLOW_PLAYER_TAG`. The default element is `<flowsvg-player>`; CSS classes and control variables use `flowsvg-` and `--flowsvg-`. Imports, selectors and public API references must use the new names.
 
 - Fixed cylinder SVG fills by rendering the top cap as a separate filled ellipse inside the same node interaction group, so the cap no longer appears hollow.
 

package/PATTERNS.md

@@ -1,12 +1,75 @@
 # Patterns
 
+- Prepare 0.2.0 from the SDK package version and verify its exact tarball before publication. Treat compiled `Diagram.beats` as the timing contract when migrating from 0.1.x; keep authored no-flow reading beats independent. Release notes describe the final 500 ms post-arrival interval. Repository release documentation distinguishes a prepared version from npm latest.
+
+- Derive single-flow post-arrival time from the 200 ms entrance, 100 ms full-paint hold and 200 ms departure constants. Evaluate departure independently of logical flags and marker progress; multiply automatic node/edge paint by the remaining weight before merging explicit highlight paint. Reduced motion bypasses both paint interpolations without changing compiled intervals.
+
+- Resolve automatic flow participant paint separately from logical membership. Single-flow senders paint immediately; receivers use a deterministic 200 ms cubic transition after movement, then automatic node/edge paint fades out during the final 200 ms. Merge paint weights with explicit highlights using max, retain logical membership at zero paint, and bypass flow paint interpolation for reduced motion and synchronized multi-flow beats. Keep this in core evaluation so static SVG, browser playback and export sample the same colors.
+
+- Separate single-flow movement from arrival hold: effective duration is reference movement plus 500 ms, replacing the authored beat duration. Keep no-flow reading and multi-flow durations authored. Cap opening transitions at effective beat length so shortened beats finish their updates before the next snapshot.
+
+- Compile authored snapshots first and route each single-flow beat at its target visual state through ordinary frame geometry. Use that path length once to derive reference movement time, then compile effective intervals without changing source documents. Cap transitions at effective beat length. Keep movement progress separate from full-beat progress; clamp arrival while retaining beat-local highlights. Export frozen `Diagram.beats` metadata for all schedule consumers, including browser steps, scene menus and GIF caption preflight. Reject non-finite movement or accumulated timing at the affected beat duration path. Multiple flows keep authored synchronized timing; reduced motion changes visuals only.
+
+- Keep live loop preference in the browser player, outside diagram documents and GIF options. Wrap only automatic positive-duration advancement, preserving elapsed remainder and speed. Explicit end seeks pause; play from the end restarts only with loop enabled. Forward dynamic adapter changes through `setLoop`, emit only `loopchange` for mode changes, and use the same scheduler in portable HTML. Recheck playback intent after synchronous restart events so a listener’s pause, seek, load or destruction wins.
+
+- Fit optional full-view height after current geometry and paint resolve. Keep origin and authored width; include stroke, exact cubic vertical extrema, exact marker orientation, label descent/halos and active flow capsules. Round outward to whole units, validate the combined finite result, and fall back to authored height for empty frames. Focus retains authored aspect and bounds. GIF validates the original option, then compiles a private snapshot without height fitting so all encoded frames share authored scale.
+
+- Round orthogonal routes after obstacle routing. Serialize quadratic bends and sample the same controls for flow distance, labels, bounds and hits. Clamp neighboring trims, reserve the straight marker approach, and reject control hulls that intersect stroked endpoint or obstacle bounds; tight corridors may reduce a bend to zero.
+
+- Measure node content while authoring documents, then store explicit dimensions. Share complete consumed block height and unresolved block overflow with fixed-size layout; never infer height from the final baseline. Measure against saturated contour clearance so nonempty cylinders reserve both full cap diameters. Combine explicit versions with their maximum required height, preserve every version/block diagnostic, and reuse nested content validation before layout. Aggregate height maxima and diagnostic entries without expanding authored collections into function arguments. Validate each computed required height before returning; individually finite source values can overflow combined height arithmetic. Accumulate a `DiagramValidationError` issue at each affected `content[index]` path, and keep finite representable results supported. Apply the existing geometric overflow tolerance to outer vertical bounds and graph-label top bounds so changing the authored origin does not create floating-point height warnings. Keep measurement independent of scene scanning, DOM, fonts, clocks and example data.
+
+- Keep natural outside-channel clearance separate from endpoint stub reservations. Compute the ancestor-aware lane with the base arrow clearance, then clamp it outward to cover both endpoint stubs; do not add the bend radius to ancestor clearance.
+
+- Try centered orthogonal bridges and single outside channels before grid search. Validate candidates against expanded obstacles and endpoint reservations. Include separate ancestor bounds for outside clearance; exclude shared ancestors and keep group interiors traversable.
+
+- Share target position allocation between curved and orthogonal routes. Apply the allocated position before constructing curve controls so cardinal arrival tangents remain exact; keep hidden inputs in each side group.
+
+- Allocate curved and orthogonal target slots from all declared incoming edges on each resolved side, independently of timeline visibility. Order slots by source position, with document order breaking ties. Keep slots in the side's central portion and follow ellipse/cylinder contours. For orthogonal routes, share the SVG marker footprint with routing and extend the endpoint obstacle through the reserved straight arrow approach so grid search cannot fold back into it. Pass evaluated stroke width to geometry. Cap reserved segments by available space in front of each port; narrow endpoint gaps must not cause backtracking through a node.
+
+- Keep tag shape in the shared content model. Resolve pill corners from final tag height during SVG serialization, after wrapping and baseline alignment. Shape must not change text layout, colors or hit targets; omitted shape keeps rounded corners.
+
+- Reuse `SelectControl` for select-only choices. The caller owns the committed value; keyboard navigation only previews until Enter/Space commits. Keep listbox selection separate from active focus, close on blur/outside press/disable, and destroy menus before removing their host. Render options as text and preserve hidden menus.
+
+- Keep control presentation in `styles.css`; use `flowsvg-play-toggle` as the Play/Pause styling hook instead of matching translated labels or DOM position. Preserve CSS variable customization, 44-pixel default targets, opt-in `flowsvg-compact` sizing, visible keyboard focus, native range semantics and hidden export states. Put progress on its own row at narrow widths and disable decorative transitions for reduced-motion users.
+
+- SDK runtime, build, tests, browser acceptance and package artifacts must own their inputs. Keep test fixtures inside the SDK and exclude them from runtime compilation. Preserve generic assertions while moving authored story wording and narrative structure to example-owned acceptance. Release verification must not build apps or private showcase packages. The browser regression runner serves only the SDK directory so external author imports fail visibly.
+
+
+- Observe GIF worker errors immediately after construction and retain the failure for the entire task. Race image decoding and worker replies with that failure as well as caller cancellation; remove all listeners and release task resources on every exit path. Request-scoped error listeners alone can miss startup errors during rasterization.
+
+- Keep release acceptance at the installed artifact boundary: copy the portable consumer verifier beside the real tarball install, then copy complete built tools/runtime dependencies away from package source. Use prepared executable paths, offline browser contexts and independent GIF decoding; never satisfy release checks by inspecting source or downloading browsers during tests. Explicitly select Node/React type libraries in strict consumer compilation.
+
+- Assemble optional GIF HTML in the Node HTML renderer by reading the same build’s `portable/export.js` before `portable/player.js`. Snapshot and validate the boolean `gifExport` option before asynchronous reads. Forward it through the inert bootstrap payload; reuse the existing player controls and exporter without importing automation or embedding a second encoder. Default HTML reads no GIF asset.
+
+- Node GIF export dynamically imports the pinned `playwright-core` runtime dependency only when launching Chromium. Reuse the pure browser planner before launch, then run the versioned `portable/export.js` inside a task-owned offline context/page. Snapshot documents/options synchronously. Close the context on abort, share its closing promise, close owned browsers including late launch results, and always remove temporary files. Never close a caller-owned browser. Route CLI HTML/GIF through one atomic publisher; exclusive links preserve existing files, and only explicit overwrite uses rename.
+
+- Keep optional GIF UI in `browser/export-controls.ts`. Reserve one task slot and capture the validated document and resolved theme before the first asynchronous boundary. Race module loading with abort, guard callbacks/downloads by task identity, and abort on player destruction. Document loads retain the old task; adapter option changes replace and destroy the old player. Reuse core JSON serialization for source snapshots so Vue reactive documents work without importing Vue into the browser player.
+- Keep the browser export import dynamic in emitted ESM. The portable IIFE build replaces only the export-controls import with an internal bridge to `FlowSVGExport`; basic HTML does not include exporter/worker code. GIF-enabled HTML must explicitly embed the separate same-version exporter asset. Keep this assembly detail out of public player options.
+
+- Validate supplied GIF option types before applying defaults or checking cancellation. Keep dimensions, sample counts and 16-bit hold-delay split counts in the pure planner so browser and Node reject limits before allocating rendering resources. Evaluate range samples on the full original timeline, clamp ordinary samples below the exclusive endpoint, and use the immediate IEEE-754 predecessor for an intermediate end-left hold. Preserve global completion with zero additional delay. Allocate delays from rounded cumulative centiseconds and bound final encoded frames, including hold splits, at 1801.
+- Preflight GIF captions by walking every overlapping source beat interval with inherited caption state, including intervals missed by sampling. Load the effective caption glyphs before measuring with the same font, wrapping, line height and padding used to paint. Preserve explicit blank lines and empty-string captions. Reject horizontal or vertical overflow with scene/beat context instead of clipping or reducing the font.
+
+- Keep browser GIF export under `src/export/`, with the public `src/export.ts` entry and a separate `portable/export.js` IIFE. Core, ordinary browser playback and base offline HTML must not eagerly load the exporter or encoder. Bundle `gifenc` only into an inline Blob worker; transfer one RGBA frame and await acknowledgement before sampling another. Keep timing/dimension planning pure, share core SVG evaluation and font/palette values, snapshot input before awaiting, and release canvas, images, object URLs, listeners and workers in every exit path. Race pending browser font/image work with AbortSignal so cancellation does not wait for those services.
+- Run SDK test files sequentially because offline integration files rebuild the shared `dist` directory. Use the independently maintained `gifuct-js` decoder for actual GIF pixels and raw GCE fields for delay assertions; its decompressed delay normalizes zero values and must not be used to verify metadata.
+
+- Keep default diagram colors and line metrics in the core theme. Use separate highlight fill, border/marker and marker-text colors so active nodes retain readable text in both themes. Browser hover consumes the same theme values; preserve border-only hover by default. Node labels have no halo; edge labels retain background isolation where paths cross text.
+
+- Keep README previews and the animated brand asset in `docs/images/` inside the SDK package. Enumerate every expected PNG and GIF asset in the release verifier; require each image and reject undeclared files. Place the logo first in a centered HTML header in both README languages. Use relative image paths in source READMEs for local previews. The release verifier unpacks the built package into a temporary directory and converts Markdown image paths and HTML image sources only in its README copies to npm CDN URLs with the package version. Repack without lifecycle scripts, require the packed file set to remain unchanged, then verify and retain that final tarball. Source READMEs must remain unchanged by release verification.
+
+- Keep shared document/frame types in `src/core/model.ts`, document validation and its single error class in `validation.ts`, and compilation, cloning/freezing, evaluation, SVG and hit-test orchestration in `diagram.ts`. Node-content types and nested validation remain in `node-content.ts`. Import runtime owners directly; use type imports for shared model dependencies.
+- Enumerate public values and types in the root entry, including `wrapText`, `Diagram` and all node-content types. Keep core contract tests in `src/core/` and consume public entries. Separate core, browser, React, Vue and Node TypeScript builds preserve the internal directory hierarchy under `dist`; check worker types separately before bundling its source. Enumerate each emitted module in the release allowlist instead of accepting arbitrary files below `dist`.
+- Keep the browser player implementation under `src/browser/player.ts`, with controls, accessibility, lifecycle, and SVG DOM synchronization beside it. Keep `src/browser.ts` as the explicit public entry; browser tests use that entry while core remains DOM-free.
+- Keep React, Vue, and Web Component implementations under `src/adapters/`; root adapter files are explicit public entries that export the single implementation and preserve runtime identity. Adapter tests live beside their implementations and cross-host business scenarios live under `tests/integration/`; imports use public entries.
+- Keep color interpolation in the pure `src/core/color.ts` module. Timeline and diagram painting import it directly so generic color rules do not depend on timeline semantics. Content highlight paint retains theme-specific semantic colors and adjusts default ink only when the evaluated fill requires more contrast.
+- Keep route construction, path measurements, label anchors, and path hit testing in `src/core/edge-geometry.ts`; share integer and three-decimal formatting through `src/core/svg-number.ts`. Diagram orchestration consumes these internal results without exposing geometry.
+
 - Run release gates sequentially through the root release CLI. Default to a preview without authentication; check authentication before the gates only for explicit publication. Copy the verified tarball after all consumer checks pass, then preview and publish that file without repacking. Stop on any command failure and keep npm stdio attached for authentication prompts.
 
 - Build Vue declarations against the pinned minimum supported version, 3.5.0; newer Vue patch releases can add inferred `DefineComponent` type parameters that older consumers cannot read. Verify both minimum and current framework versions in the packed-package consumer.
 
 - Build through `prepack` so `npm pack` and directory publishing cannot use missing or stale artifacts. Keep publish-only type/test checks separate from packaging to avoid recursive release verification. Verify the packed exports and strict consumer types before publishing.
 
-- Publish the SDK as `flowsvg` from `packages/flowsvg`. Use the `Flow` prefix for player exports, `<flowsvg-player>` for the default custom element, and `flowsvg-` / `--flowsvg-` for CSS classes and control variables. Keep package imports, declarations, examples and release verification aligned with these names.
+- Use FlowSVG as the display name. Publish the SDK as `flowsvg` from `packages/flowsvg`. Use the `Flow` prefix for player exports, `<flowsvg-player>` for the default custom element, and `flowsvg-` / `--flowsvg-` for CSS classes and control variables. Keep package imports, declarations, examples and release verification aligned with these names.
 
 - Apply hover to stroke only by default for every node and group. Preserve core fill and content paint, including active flow or explicit highlights. With `hoverFill: true`, paint fill and readable content as well. Forward the same option through every adapter and restore the current core SVG when the pointer leaves.
 
@@ -33,14 +96,14 @@
 
 - Keep structured node content in a deterministic module that accepts current absolute geometry and a resolved theme. Return the complete layout plus a nonnegative safe area, then consume those same lines and clip geometry in SVG. Keep content child groups keyed separately from the node shape; only the shape uses its node `data-id`. Validate controlled nested fields before cloning, and preserve simple-label overflow behavior.
 
-- Preserve collinear extrema when compacting path points: a reversal contributes distance and bounds even when all samples lie on one axis. For explicit orthogonal ports, reserve outward endpoint stubs before grid search and include inflated endpoint bodies among middle-route obstacles; leave fully automatic routing unchanged.
+- Preserve collinear extrema when compacting path points: a reversal contributes distance and bounds even when all samples lie on one axis. For all orthogonal ports, reserve outward endpoint segments before grid search and include inflated endpoint bodies among middle-route obstacles. Reduce reserved segments in narrow gaps so stubs do not enter the opposite node.
 
 - Keep hover in the browser paint layer: restore the current core SVG before applying a hovered node's shared-theme highlight colors. Re-hit the saved screen position through the updated camera after each frame. Include nonempty node label bounds using the capsule's shared width estimate for wide characters. Clear interaction causes on pointer cancellation, successful load, and destroy. Never write hover into the core frame or timeline; removing hover must expose the current explicit/flow highlight or ordinary style.
 - Render transfer text from the evaluated beat-local `flow.text`, without changing the edge label. Estimate capsule width by Unicode code points with full-em space for wide characters, retain horizontal text, escape plain SVG content, and disable marker pointer handling. Verify current browser messages and static SVG equality with `tests/browser-flow-text.html`.
 
-- Treat each beat’s transfers as a synchronized group: derive all marker positions from the same linear progress and union endpoint highlight reasons. Reject a second flow for the same edge regardless of direction or other field errors; keep flow assignments separate from visibility, explicit highlights, and base updates.
+- Treat multiple transfers in a beat as a synchronized group: derive their marker positions from the same linear progress and union endpoint highlight reasons. Reject a second flow for the same edge regardless of direction or other field errors; keep flow assignments separate from visibility, explicit highlights, and base updates.
 
-- Compile `flow` actions as beat-local state: use the full beat progress for distance-based marker sampling, keep static edge arrows unchanged for reverse transfers, and derive temporary edge/endpoint highlights during frame evaluation so they expire without overwriting explicit highlights or ordinary style updates.
+- Compile `flow` actions as beat-local state: sample markers by movement progress for a single transfer and full-beat progress for multiple transfers, keep static edge arrows unchanged for reverse transfers, and derive temporary edge/endpoint highlights during frame evaluation so they expire without overwriting explicit highlights or ordinary style updates.
 - Generate curved routes from cardinal port normals and use the same sampled geometry for path consumers. Keep endpoint control points on the outward side of each port so the path enters the target along the inverse normal; separate reverse relationships with a deterministic perpendicular lane.
 
 - Keep the native business example in a fixed view: use the same document across public integration checks, synchronize three request paths then two processing paths, and return messages through reverse flows and a separate response relationship. Compare public frame/SVG output at beat boundaries rather than adding adapter clocks or test-only APIs.
@@ -99,3 +162,7 @@
 - Validate every document field and reference before compilation; reject unsafe colors and duplicate timeline assignments with field paths.
 - Route orthogonal edges against evaluated absolute geometry and inherited visibility; exclude group frames from obstacles and serialize direction markers with the same paths.
 - Build each evaluated edge once as internal path geometry with its serialized path, points, length, bounds, and distance-based sampling; use that geometry for labels, focus bounds, hit testing, and active flow sampling so consumers cannot drift apart.
+
+- Build portable browser assets with an explicit esbuild entry and a same-version manifest. Node HTML assembly reads only built assets and core modules; browser automation and GIF dependencies stay outside this path. Snapshot and validate document/options before asynchronous reads, embed JSON as inert escaped data, and escape page titles separately. CLI writes a sibling temporary file, then links without replacement or renames only when overwrite is explicit. Always remove temporary files on publication failure.
+
+- Compile `flow.highlightParticipants` with default true. Apply this policy only to temporary endpoint highlights; keep explicit node highlights, temporary edge highlights and marker evaluation independent. State-machine stories can then animate event transfers while retaining one current state. Reduced motion suppresses markers and retains configured highlights.