@formicoidea/labre-core 0.31.0 → 0.32.0

package/dist/_pkgs/affine-components/open-doc-dropdown-menu/dropdown-menu.d.ts

@@ -17,6 +17,7 @@ export declare class OpenDocDropdownMenu extends OpenDocDropdownMenu_base {
         when?: ((cx: ToolbarContext) => boolean) | boolean;
         active?: ((cx: ToolbarContext) => boolean) | boolean;
         placement?: import("../../affine-shared/services/index.js").ActionPlacement;
+        priority?: number;
     } & {
         label?: string;
         showLabel?: boolean;

package/dist/_pkgs/affine-components/portal/portal.d.ts

@@ -17,7 +17,7 @@ import { LitElement, type TemplateResult } from 'lit';
  */
 export declare class Portal extends LitElement {
     private _portalRoot;
-    createRenderRoot(): ShadowRoot | HTMLDivElement;
+    createRenderRoot(): HTMLDivElement | ShadowRoot;
     disconnectedCallback(): void;
     render(): TemplateResult | undefined;
     accessor container: HTMLElement;

package/dist/_pkgs/affine-components/toolbar/menu-button.js

@@ -235,6 +235,7 @@ export class EditorMenuAction extends LitElement {
       color: var(--affine-text-primary-color);
       font-weight: 400;
       min-height: 30px; // 22 + 8
+      user-select: none;
     }
 
     :host(:hover),

package/dist/_pkgs/affine-components/toolbar/toolbar.js

@@ -6,14 +6,13 @@ export class EditorToolbar extends WithDisposable(LitElement) {
     static { this.styles = css `
     ${panelBaseStyle(':host')}
     :host {
-      min-height: 36px;
+      /* ONE line, always: the toolbar's height never depends on the selection,
+         so it never moves under the cursor. When the row runs out of room the
+         widget spends its entries — icon only first, then into the "⋮" menu —
+         rather than growing a second row (PO arbitration of 02/08/2026). */
+      height: 36px;
       box-sizing: content-box;
-      /* ponytail: wrap to a second row instead of overflowing on mobile. The
-         width is capped to availableWidth by floating-ui's size middleware;
-         wrapping (not scrolling) keeps the "More" dropdown clickable — it is a
-         descendant of this toolbar, so an overflow container would clip it. */
-      flex-wrap: wrap;
-      row-gap: 4px;
+      flex-wrap: nowrap;
     }
 
     :host([data-without-bg]) {
@@ -24,9 +23,11 @@ export class EditorToolbar extends WithDisposable(LitElement) {
 
     ::slotted(*) {
       display: flex;
-      /* fixed row height (not 100%) so each item stays one row tall when the
-         toolbar wraps to multiple rows */
-      height: 36px;
+      height: 100%;
+      /* Entries keep their natural width: squashing them into the row would
+         hide the overflow the widget has to measure, and a button squeezed to
+         half a word is worse than the same button in the "⋮" menu. */
+      flex-shrink: 0;
       justify-content: center;
       align-items: center;
       gap: 8px;

package/dist/_pkgs/affine-foundation/view.js

@@ -1,7 +1,7 @@
 import { FileDropExtension } from '../affine-components/drop-indicator/index.js';
 import { PeekViewExtension, } from '../affine-components/peek/index.js';
 import { ViewExtensionProvider, } from '../affine-ext-loader/index.js';
-import { AutoClearSelectionService, BlockCommentManager, BlockLifecycleTelemetryWatcher, CitationService, DefaultOpenDocExtension, DNDAPIExtension, DocDisplayMetaService, DocModeService, EditPropsStore, EmbedOptionService, FileSizeLimitService, FontConfigExtension, fontConfigSchema, FontLoaderService, LinkPreviewCache, LinkPreviewCacheConfigSchema, LinkPreviewCacheExtension, LinkPreviewService, PageViewportServiceExtension, TelemetryExtension, ThemeService, ToolbarRegistryExtension, } from '../affine-shared/services/index.js';
+import { AutoClearSelectionService, BlockCommentManager, BlockLifecycleTelemetryWatcher, CitationService, DefaultOpenDocExtension, DNDAPIExtension, DocDisplayMetaService, DocModeService, EditPropsStore, EmbedOptionService, FileSizeLimitService, FontConfigExtension, fontConfigSchema, FontLoaderService, LinkPreviewCache, LinkPreviewCacheConfigSchema, LinkPreviewCacheExtension, LinkPreviewService, PageViewportServiceExtension, PivotMaterialityPublisher, TelemetryExtension, ThemeService, ToolbarRegistryExtension, } from '../affine-shared/services/index.js';
 import { InteractivityManager, ToolController } from '../std/gfx/index.js';
 import { z } from 'zod';
 import { clipboardConfigs } from './clipboard.js';
@@ -47,7 +47,16 @@ export class FoundationViewExtension extends ViewExtensionProvider {
         ]);
         context.register(clipboardConfigs);
         if (this.isEdgeless(context.scope)) {
-            context.register([InteractivityManager, ToolController]);
+            context.register([
+                InteractivityManager,
+                ToolController,
+                // Inert without a host `PivotPropertiesProvider` that implements the
+                // write-back; see ADR 0006 § 4. NOT flag-gated: reflecting a bound
+                // element's qualification onto its record is a property of the
+                // document, not a piece of framework tooling, and it must keep working
+                // for a board whose framework flag is off.
+                PivotMaterialityPublisher,
+            ]);
         }
         const fontConfig = options?.fontConfig;
         if (fontConfig) {

package/dist/_pkgs/affine-gfx-brush/index.d.ts

@@ -3,5 +3,6 @@ export * from './brush-tool.js';
 export * from './element-renderer.js';
 export * from './eraser-tool.js';
 export * from './highlighter-tool.js';
+export * from './renderer/index.js';
 export * from './toolbar/configs/index.js';
 export * from './toolbar/senior-tool.js';

package/dist/_pkgs/affine-gfx-brush/index.js

@@ -3,5 +3,6 @@ export * from './brush-tool.js';
 export * from './element-renderer.js';
 export * from './eraser-tool.js';
 export * from './highlighter-tool.js';
+export * from './renderer/index.js';
 export * from './toolbar/configs/index.js';
 export * from './toolbar/senior-tool.js';

package/dist/_pkgs/affine-gfx-brush/renderer/dom/brush.d.ts

@@ -0,0 +1 @@
+export declare const BrushDomRendererExtension: import("../../../store/index.js").ExtensionType;

package/dist/_pkgs/affine-gfx-brush/renderer/dom/brush.js

@@ -0,0 +1,11 @@
+import { DomElementRendererExtension, } from '../../../affine-block-surface/index.js';
+import { DefaultTheme } from '../../../affine-model/index.js';
+import { renderBrushLikeDom } from './shared.js';
+export const BrushDomRendererExtension = DomElementRendererExtension('brush', (model, domElement, renderer) => {
+    renderBrushLikeDom({
+        model,
+        domElement,
+        renderer,
+        color: renderer.getColorValue(model.color, DefaultTheme.black, true),
+    });
+});

package/dist/_pkgs/affine-gfx-brush/renderer/dom/highlighter.d.ts

@@ -0,0 +1 @@
+export declare const HighlighterDomRendererExtension: import("../../../store/index.js").ExtensionType;

package/dist/_pkgs/affine-gfx-brush/renderer/dom/highlighter.js

@@ -0,0 +1,11 @@
+import { DomElementRendererExtension, } from '../../../affine-block-surface/index.js';
+import { DefaultTheme } from '../../../affine-model/index.js';
+import { renderBrushLikeDom } from './shared.js';
+export const HighlighterDomRendererExtension = DomElementRendererExtension('highlighter', (model, domElement, renderer) => {
+    renderBrushLikeDom({
+        model,
+        domElement,
+        renderer,
+        color: renderer.getColorValue(model.color, DefaultTheme.hightlighterColor, true),
+    });
+});

package/dist/_pkgs/affine-gfx-brush/renderer/dom/index.d.ts

@@ -0,0 +1,2 @@
+export { BrushDomRendererExtension } from './brush.js';
+export { HighlighterDomRendererExtension } from './highlighter.js';

package/dist/_pkgs/affine-gfx-brush/renderer/dom/index.js

@@ -0,0 +1,2 @@
+export { BrushDomRendererExtension } from './brush.js';
+export { HighlighterDomRendererExtension } from './highlighter.js';

package/dist/_pkgs/affine-gfx-brush/renderer/dom/shared.d.ts

@@ -0,0 +1,14 @@
+import type { DomRenderer } from '../../../affine-block-surface/index.js';
+import type { BrushElementModel, HighlighterElementModel } from '../../../affine-model/index.js';
+type BrushLikeModel = BrushElementModel | HighlighterElementModel;
+/**
+ * Paints a brush or highlighter stroke into its host element. The z-index is
+ * owned by `DomRenderer`, which reads it from the layer manager.
+ */
+export declare function renderBrushLikeDom({ color, domElement, model, renderer, }: {
+    color: string;
+    domElement: HTMLElement;
+    model: BrushLikeModel;
+    renderer: DomRenderer;
+}): void;
+export {};

package/dist/_pkgs/affine-gfx-brush/renderer/dom/shared.js

@@ -0,0 +1,54 @@
+const SVG_NS = 'http://www.w3.org/2000/svg';
+/**
+ * The nodes a stroke host already owns, kept across renders. Rebuilding the
+ * `<svg>` on every frame allocated one element per stroke per pan or zoom;
+ * the attributes are cheap to overwrite in place.
+ */
+const retainedBrushDom = new WeakMap();
+function clearBrushLikeDom(domElement) {
+    retainedBrushDom.delete(domElement);
+    domElement.replaceChildren();
+}
+function getRetainedBrushDom(domElement) {
+    const existing = retainedBrushDom.get(domElement);
+    if (existing) {
+        return existing;
+    }
+    const svg = document.createElementNS(SVG_NS, 'svg');
+    svg.style.position = 'absolute';
+    svg.style.left = '0';
+    svg.style.top = '0';
+    svg.style.overflow = 'visible';
+    svg.style.pointerEvents = 'none';
+    const path = document.createElementNS(SVG_NS, 'path');
+    path.setAttribute('stroke', 'none');
+    svg.append(path);
+    const retained = { svg, path };
+    retainedBrushDom.set(domElement, retained);
+    domElement.replaceChildren(svg);
+    return retained;
+}
+/**
+ * Paints a brush or highlighter stroke into its host element. The z-index is
+ * owned by `DomRenderer`, which reads it from the layer manager.
+ */
+export function renderBrushLikeDom({ color, domElement, model, renderer, }) {
+    const { zoom } = renderer.viewport;
+    const [, , w, h] = model.deserializedXYWH;
+    if (w <= 0 || h <= 0 || !model.commands) {
+        clearBrushLikeDom(domElement);
+        return;
+    }
+    const { path, svg } = getRetainedBrushDom(domElement);
+    svg.style.width = `${w * zoom}px`;
+    svg.style.height = `${h * zoom}px`;
+    svg.style.transform = model.rotate === 0 ? '' : `rotate(${model.rotate}deg)`;
+    svg.style.transformOrigin = model.rotate === 0 ? '' : 'center';
+    svg.setAttribute('viewBox', `0 0 ${w} ${h}`);
+    path.setAttribute('d', model.commands);
+    path.setAttribute('fill', color);
+    domElement.style.width = `${w * zoom}px`;
+    domElement.style.height = `${h * zoom}px`;
+    domElement.style.overflow = 'visible';
+    domElement.style.pointerEvents = 'none';
+}

package/dist/_pkgs/affine-gfx-brush/renderer/index.d.ts

@@ -0,0 +1 @@
+export * from './dom/index.js';

package/dist/_pkgs/affine-gfx-brush/renderer/index.js

@@ -0,0 +1,4 @@
+// The canvas (2d context) renderers still live in `../element-renderer.ts`
+// (brush) and in `@labre/affine-gfx-shape` (highlighter); only the DOM
+// variants are collected here.
+export * from './dom/index.js';

package/dist/_pkgs/affine-gfx-brush/view.d.ts

@@ -1,4 +1,18 @@
 import { type ViewExtensionContext, ViewExtensionProvider } from '../affine-ext-loader/index.js';
+/**
+ * Brush / highlighter rendering — ALWAYS registered, independent of any flag.
+ * Disabling `brush` hides only the pen senior button and the tools it opens
+ * (see {@link BrushViewExtension}); strokes already drawn must still paint,
+ * stay selectable and keep their contextual toolbar. See `docs/adr/0009`.
+ */
+export declare class BrushRenderViewExtension extends ViewExtensionProvider {
+    name: string;
+    setup(context: ViewExtensionContext): void;
+}
+/**
+ * Pen creation tooling — flag-gated (`brush`): the senior toolbar button and
+ * the brush / highlighter / eraser tools it opens.
+ */
 export declare class BrushViewExtension extends ViewExtensionProvider {
     name: string;
     effect(): void;

package/dist/_pkgs/affine-gfx-brush/view.js

@@ -4,8 +4,36 @@ import { effects } from './effects.js';
 import { BrushElementRendererExtension } from './element-renderer.js';
 import { EraserTool } from './eraser-tool.js';
 import { HighlighterTool } from './highlighter-tool.js';
+import { BrushDomRendererExtension, HighlighterDomRendererExtension, } from './renderer/index.js';
 import { brushToolbarExtension, highlighterToolbarExtension, } from './toolbar/configs/index.js';
 import { penSeniorTool } from './toolbar/senior-tool.js';
+/**
+ * Brush / highlighter rendering — ALWAYS registered, independent of any flag.
+ * Disabling `brush` hides only the pen senior button and the tools it opens
+ * (see {@link BrushViewExtension}); strokes already drawn must still paint,
+ * stay selectable and keep their contextual toolbar. See `docs/adr/0009`.
+ */
+export class BrushRenderViewExtension extends ViewExtensionProvider {
+    constructor() {
+        super(...arguments);
+        this.name = 'affine-brush-render-gfx';
+    }
+    setup(context) {
+        super.setup(context);
+        context.register(BrushElementRendererExtension);
+        // DOM variants of the same two strokes. The canvas renderer for the
+        // highlighter still ships with `@labre/affine-gfx-shape`; both providers
+        // are always-on, so the pair stays complete whatever the `brush` flag says.
+        context.register(BrushDomRendererExtension);
+        context.register(HighlighterDomRendererExtension);
+        context.register(brushToolbarExtension);
+        context.register(highlighterToolbarExtension);
+    }
+}
+/**
+ * Pen creation tooling — flag-gated (`brush`): the senior toolbar button and
+ * the brush / highlighter / eraser tools it opens.
+ */
 export class BrushViewExtension extends ViewExtensionProvider {
     constructor() {
         super(...arguments);
@@ -13,6 +41,7 @@ export class BrushViewExtension extends ViewExtensionProvider {
     }
     effect() {
         super.effect();
+        // Defines the pen/eraser tool buttons and the pen menu — tooling only.
         effects();
     }
     setup(context) {
@@ -20,9 +49,6 @@ export class BrushViewExtension extends ViewExtensionProvider {
         context.register(BrushTool);
         context.register(EraserTool);
         context.register(HighlighterTool);
-        context.register(BrushElementRendererExtension);
-        context.register(brushToolbarExtension);
-        context.register(highlighterToolbarExtension);
         context.register(penSeniorTool);
     }
 }

package/dist/_pkgs/affine-gfx-connector/connector-manager.js

@@ -985,6 +985,17 @@ export class ConnectorPathGenerator extends PathGenerator {
             getElementById: elementGetter ?? (() => null),
         });
         const points = path ?? instance._generateConnectorPath(connector) ?? [];
+        // Degraded state: no resolvable endpoints (an endpoint references a
+        // missing element and has no fallback position). Keep the last bound and
+        // paint nothing rather than derive a bbox from an empty point set.
+        if (points.length === 0) {
+            if (connector.path.length > 0) {
+                connector.updatingPath = true;
+                connector.path = [];
+                connector.updatingPath = false;
+            }
+            return;
+        }
         const bound = connector.mode === ConnectorMode.Curve
             ? getBezierCurveBoundingBox(getBezierParameters(points))
             : getBoundFromPoints(points);
@@ -1052,6 +1063,11 @@ export class ConnectorPathGenerator extends PathGenerator {
             const start = this._getConnectorEndElement(connector, 'source');
             const end = this._getConnectorEndElement(connector, 'target');
             const [startPoint, endPoint] = this._computeStartEndPoint(connector);
+            // _computeStartEndPoint returns [] when an endpoint cannot be resolved
+            // (e.g. its element is gone and no position is stored) — bail out
+            // instead of feeding undefined points to the orthogonal router.
+            if (!startPoint || !endPoint)
+                return [];
             const startBound = start
                 ? Bound.from(getBoundWithRotation(rBound(start)))
                 : null;
@@ -1076,9 +1092,12 @@ export class ConnectorPathGenerator extends PathGenerator {
         let startPoint = null;
         let endPoint = null;
         if (source.id || target.id) {
-            if (!source.position && !target.position) {
-                const start = this._getConnectorEndElement(connector, 'source');
-                const end = this._getConnectorEndElement(connector, 'target');
+            const start = this._getConnectorEndElement(connector, 'source');
+            const end = this._getConnectorEndElement(connector, 'target');
+            // An endpoint id may reference an element that no longer exists.
+            // Only take the anchor-to-anchor shortcut when both resolve; otherwise
+            // degrade through _getConnectionPoint (stored position or empty path).
+            if (start && end && !source.position && !target.position) {
                 const sb = Bound.deserialize(start.xywh);
                 const eb = Bound.deserialize(end.xywh);
                 startPoint = getNearestConnectableAnchor(start, eb.center);
@@ -1150,9 +1169,16 @@ export class ConnectorPathGenerator extends PathGenerator {
     }
     _generateStraightConnectorPath(connector) {
         const { source, target } = connector;
-        if (source.id && !source.position && target.id && !target.position) {
-            const start = this._getConnectorEndElement(connector, 'source');
-            const end = this._getConnectorEndElement(connector, 'target');
+        const start = this._getConnectorEndElement(connector, 'source');
+        const end = this._getConnectorEndElement(connector, 'target');
+        // Same degraded state as in _generateCurveConnectorPath: an endpoint id
+        // whose element is gone falls through to _getConnectionPoint.
+        if (source.id &&
+            !source.position &&
+            target.id &&
+            !target.position &&
+            start &&
+            end) {
             const sb = Bound.deserialize(start.xywh);
             const eb = Bound.deserialize(end.xywh);
             const startPoint = getNearestConnectableAnchor(start, eb.center);

package/dist/_pkgs/affine-gfx-connector/connector-tool.d.ts

@@ -4,6 +4,13 @@ import type { PointerEventState } from '../std/index.js';
 import { BaseTool, type GfxModel } from '../std/gfx/index.js';
 export type ConnectorToolOptions = {
     mode: ConnectorMode;
+    /**
+     * Semantic role (`<framework>:<role>`) stamped on the connectors drawn while
+     * this activation lasts — a framework toolbox activates the tool for a typed
+     * edge (e.g. `wardley:dependency`). Left out for the plain connector tool:
+     * the edge then stays neutral and no `role` key is written.
+     */
+    role?: string;
 };
 export declare class ConnectorTool extends BaseTool<ConnectorToolOptions> {
     static toolName: string;

package/dist/_pkgs/affine-gfx-connector/connector-tool.js

@@ -37,7 +37,8 @@ export class ConnectorTool extends BaseTool {
         const id = this.gfx.surface.addElement({
             type: CanvasElementType.CONNECTOR,
             mode: this.activatedOption.mode,
-            controllers: [],
+            // `undefined` writes nothing: a neutral edge keeps no `role` key.
+            role: this.activatedOption.role,
             source: this._source,
             target: { position: this._startPoint },
         });

package/dist/_pkgs/affine-gfx-connector/direction/direction-reveal.d.ts

@@ -0,0 +1,123 @@
+import type { ConnectorElementModel } from '../../affine-model/index.js';
+import type { IVec } from '../../global/gfx/index.js';
+import { InteractivityExtension } from '../../std/gfx/index.js';
+import { type TypedEdge } from './typed-edge.js';
+/**
+ * **M2 of `docs/adr/0010` — "show it".**
+ *
+ * A typed edge reveals its orientation on hover and on selection: ONE mark, the
+ * role's verb laid ALONG the link — `depends on` — in a box whose far end is a
+ * point aimed at the target. At rest the board keeps the canonical arrowless
+ * look, because on a Wardley map a permanent head already means something else
+ * (evolution movement), and two meanings on one glyph make both unreadable.
+ *
+ * ## The chevron is gone (PO acceptance of 02/08/2026, point 5)
+ *
+ * The first cut of M2 drew two marks: a canvas chevron at the target end, and
+ * a horizontal DOM tooltip holding the bare verb. Two things were wrong with
+ * it, and they had one cause between them.
+ *
+ * - The label was placed on `path[floor(length / 2)]`, the middle VERTEX. A
+ *   straight link has exactly two points, so the "middle" vertex IS the target
+ *   end — the tooltip landed on the tip of the link and covered the chevron it
+ *   was meant to complement.
+ * - Even placed correctly, a horizontal box across a diagonal link reads as a
+ *   sticker dropped on the map rather than as a statement about that link.
+ *
+ * The fix is one mark instead of two: the verb, rotated onto the line,
+ * ending in the point that used to be a separate chevron. So this file no
+ * longer owns a canvas overlay at all — {@link labelAnchorOf} says where the
+ * label goes and which way it turns, and the DOM widget draws it. Nothing can
+ * overlap something that no longer exists.
+ *
+ * ## Why a manager, and not the element renderer
+ *
+ * An `ElementRenderer` is `(model, ctx, matrix, renderer, rc)`: it knows the
+ * element and knows nothing about hover or selection, which are the two things
+ * this affordance is made of. So the state lives in an `InteractivityExtension`
+ * that owns two signals, and the widget reads them.
+ *
+ * Nothing here touches an element model: no CRDT write, no undo entry, not even
+ * a `@local()` field. The reveal is session state and leaves with the pointer.
+ */
+/**
+ * The one colour the reveal is drawn in — the house primary, i.e. the colour of
+ * an affordance rather than of ink. Deliberately NOT the framework's palette:
+ * the label is the tool talking about the drawing, not part of the drawing.
+ */
+export declare const EDGE_DIRECTION_COLOR = "#1e96eb";
+/**
+ * Where the label sits on a typed edge, and how it is turned.
+ *
+ * All of it in MODEL space: the widget projects `at` through the viewport and
+ * scales the box by the zoom, so the label is glued to its link the way a
+ * street name is glued to its street.
+ */
+export interface EdgeLabelAnchor {
+    /** The model point the label CENTRES on — the middle of the drawn path. */
+    at: IVec;
+    /**
+     * Rotation in radians, always within `[-π/2, π/2]`: the angle of the median
+     * segment, turned by 180° when that angle would stand the text on its head.
+     */
+    angle: number;
+    /**
+     * Whether that 180° turn happened. It is the whole reason the caller needs
+     * this flag: the point of the box must face the TARGET, so on a link running
+     * right-to-left — where the turn put the box's right end at the SOURCE — the
+     * point moves to the box's left end. The words themselves never reverse; a
+     * mirrored `depends on` would be a smudge, not a rotation.
+     */
+    flipped: boolean;
+}
+/**
+ * Where a typed edge's label goes and how it is turned — the whole geometry
+ * of M2 since the chevron was folded into the label.
+ *
+ * `null` for an edge with no direction to show: no routed path yet, or a path
+ * whose points all coincide. Silence, not a guess.
+ */
+export declare function labelAnchorOf(model: ConnectorElementModel): EdgeLabelAnchor | null;
+/**
+ * Owns "which typed edges are revealing their direction", and the hint the
+ * armed tool shows (M1). Both are session state, both are signals, and both are
+ * read by the overlay and by the widget — so the two halves of the affordance
+ * can never disagree about what is on screen.
+ *
+ * No-op until some framework registers a role vocabulary: on a board of
+ * generalist connectors this subscribes to nothing at all.
+ */
+export declare class EdgeDirectionManager extends InteractivityExtension {
+    static key: string;
+    /** Ids of the typed edges revealing their direction: hover ∪ selection. */
+    readonly revealed$: import("@preact/signals-core").Signal<readonly string[]>;
+    /**
+     * The gesture hint of the armed tool, when that tool draws a typed edge —
+     * M1's half of the affordance. `null` for every other tool, which is every
+     * tool whose gesture decides no persisted orientation.
+     */
+    readonly armedHint$: import("@preact/signals-core").Signal<{
+        key: string;
+        fallback?: string;
+    } | null>;
+    private _hovered;
+    private _subscriptions;
+    private _vocabularies;
+    private get _roles();
+    /**
+     * The revealed edges, resolved NOW rather than remembered.
+     *
+     * The same reasoning as the validation overlay's: the widget re-renders far
+     * more often than this state changes, and an edge can lose a binding or a
+     * role between two frames. A frozen snapshot would keep labelling a relation
+     * that no longer exists.
+     */
+    revealedEdges(): TypedEdge[];
+    mounted(): void;
+    unmounted(): void;
+    private _hover;
+    private _setHovered;
+    private _syncArmed;
+    /** Recompute hover ∪ selection, and publish only when it actually changed. */
+    private _sync;
+}