@grafloria/element 0.3.18 → 0.3.20

package/src/libs/renderer/src/svg/route-memo.js

@@ -0,0 +1,206 @@
+"use strict";
+// Wave 8 (Performance & scale) — Card 6: route only what actually changed.
+//
+// THE BUG THIS EXISTS TO KILL. `renderLinksLayer` re-routed EVERY visible link
+// on EVERY frame:
+//
+//     for (const link of sortedLinks) { ... this.computeAutoRoute(link, endpoints) ... }
+//
+// whether or not anything had moved. Obstacle-avoiding routing is not cheap, so
+// an idle frame paid for a full re-solve of the visible scene, and moving ONE
+// node cost 5.5 seconds at 10k nodes — O(scene) work for an O(1) edit.
+//
+// WHAT MAKES A ROUTE STALE. Two different things, and getting only the first is
+// the trap:
+//
+//   1. The link's own inputs changed — its endpoints moved (because a node it is
+//      attached to moved or resized), its router changed, its lane in a parallel
+//      bundle changed. This is captured by the cache KEY: the key is built from
+//      the routing inputs, so a change to any of them is a miss. Endpoint moves
+//      need no special case at all — the endpoint coordinates ARE the key.
+//
+//   2. THE OBSTACLE CASE, which "did an endpoint move?" misses entirely: a node
+//      that this link does not touch moved INTO (or OUT OF) the corridor the
+//      link routes through. Nothing about the link changed; its correct route
+//      did. A cache that only watches endpoints serves a route straight through
+//      the new obstacle — fast and wrong.
+//
+// Wave 4 hit this same shape from the other side: the link VNode cache keyed off
+// `link.isDirty`, but a link's rendered output also depends on where its NODES
+// went, so it served stale geometry. The fix there was `markLinksWhoseFrameChanged`.
+// This is the same discipline one level down, on the ROUTE rather than the VNode.
+//
+// HOW CASE 2 IS CAUGHT. Every frame we diff the node rectangles against last
+// frame's. Each node that moved, resized, appeared or vanished contributes its
+// OLD and NEW rectangles as a dirty region. The engine's link spatial index —
+// which is keyed on each link's routed bounding box, because `syncLinkPoints`
+// refreshes it — is then asked which links' boxes intersect those regions,
+// inflated by the routing clearance. Those links are invalidated. A link that
+// neither moved nor had its corridor disturbed keeps its route, forever, for
+// free.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouteMemo = exports.ROUTE_INFLUENCE_PAD = void 0;
+exports.inflate = inflate;
+exports.coalesce = coalesce;
+/**
+ * How far outside a link's routed bounding box an obstacle can still have shaped
+ * that route. The router pushes off the port by `gapOffset` (30), keeps
+ * `obstacleMargin` (20) clearance from every body, and moves on a `gridSize`
+ * (10) lattice — so an obstacle that shaped this route is within ~60 units of
+ * it. 80 buys margin over that without pulling in half the diagram.
+ *
+ * This is the one approximation in the cache, and it is deliberately generous:
+ * being too eager here costs a re-route, being too clever costs a wrong route.
+ */
+exports.ROUTE_INFLUENCE_PAD = 80;
+/** Entries above this are evicted oldest-first — a deleted link must not leak forever. */
+const MAX_ENTRIES = 50000;
+class RouteMemo {
+    constructor() {
+        this.entries = new Map();
+        this.prevRects = new Map();
+        /** Bumped by the caller when something OUTSIDE the node rects changes the obstacle set. */
+        this.epoch = '';
+        this._stats = { routed: 0, reused: 0 };
+    }
+    get stats() {
+        return this._stats;
+    }
+    get size() {
+        return this.entries.size;
+    }
+    /**
+     * Start a frame. Diffs this frame's node rectangles against last frame's and
+     * returns the world regions that changed — each moved node contributes BOTH
+     * where it was and where it now is, because a link routed around its old
+     * position is just as stale as one routed through its new one.
+     *
+     * `obstacleEpoch` covers obstacle-set changes that are NOT node rects — a
+     * group collapsing hides its members and adds a block, and no node moved. A
+     * change there drops the whole cache, which is the honest thing to do: it is
+     * rare, and reasoning about which links a collapse touched is how you ship a
+     * stale route.
+     */
+    beginFrame(rects, obstacleEpoch) {
+        this._stats = { routed: 0, reused: 0 };
+        if (obstacleEpoch !== this.epoch) {
+            this.epoch = obstacleEpoch;
+            this.entries.clear();
+            this.prevRects = rects;
+            // Everything is stale; no point enumerating regions.
+            return [];
+        }
+        const dirty = [];
+        for (const [id, now] of rects) {
+            const before = this.prevRects.get(id);
+            if (!before) {
+                dirty.push(now); // appeared
+                continue;
+            }
+            if (before.x !== now.x ||
+                before.y !== now.y ||
+                before.width !== now.width ||
+                before.height !== now.height) {
+                dirty.push(before); // vacated
+                dirty.push(now); // occupied
+            }
+        }
+        for (const [id, before] of this.prevRects) {
+            if (!rects.has(id))
+                dirty.push(before); // vanished
+        }
+        this.prevRects = rects;
+        return dirty;
+    }
+    /** The route for this link if its inputs are unchanged since we cached it. */
+    lookup(linkId, key) {
+        const hit = this.entries.get(linkId);
+        if (!hit || hit.key !== key)
+            return undefined;
+        this._stats.reused++;
+        return hit.routed;
+    }
+    store(linkId, key, routed) {
+        this._stats.routed++;
+        if (this.entries.size >= MAX_ENTRIES && !this.entries.has(linkId)) {
+            // Map iterates in insertion order, so this drops the oldest.
+            const oldest = this.entries.keys().next();
+            if (!oldest.done)
+                this.entries.delete(oldest.value);
+        }
+        this.entries.set(linkId, { key, routed });
+    }
+    /** A route computed but NOT cacheable (e.g. no route found) must not keep a stale entry. */
+    drop(linkId) {
+        this.entries.delete(linkId);
+    }
+    invalidate(linkIds) {
+        for (const id of linkIds)
+            this.entries.delete(id);
+    }
+    clear() {
+        this.entries.clear();
+        this.prevRects.clear();
+        this.epoch = '';
+    }
+}
+exports.RouteMemo = RouteMemo;
+/** Grow a rect by `pad` on every side. */
+function inflate(r, pad) {
+    return {
+        x: r.x - pad,
+        y: r.y - pad,
+        width: r.width + pad * 2,
+        height: r.height + pad * 2,
+    };
+}
+/**
+ * Merge dirty rects that overlap or nearly touch, so a drag of one node does not
+ * fire N separate spatial queries. Cheap and approximate: one pass, absorbing
+ * into the first box that already covers the candidate's neighbourhood. The
+ * result is a SUPERSET of the input regions, which is the safe direction — it
+ * can only invalidate more links, never fewer.
+ */
+function coalesce(rects, maxBoxes = 16) {
+    if (rects.length <= 1)
+        return rects;
+    const boxes = [];
+    for (const r of rects) {
+        let merged = false;
+        for (let i = 0; i < boxes.length; i++) {
+            const b = boxes[i];
+            if (r.x <= b.x + b.width &&
+                r.x + r.width >= b.x &&
+                r.y <= b.y + b.height &&
+                r.y + r.height >= b.y) {
+                const minX = Math.min(b.x, r.x);
+                const minY = Math.min(b.y, r.y);
+                const maxX = Math.max(b.x + b.width, r.x + r.width);
+                const maxY = Math.max(b.y + b.height, r.y + r.height);
+                boxes[i] = { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+                merged = true;
+                break;
+            }
+        }
+        if (!merged)
+            boxes.push(Object.assign({}, r));
+    }
+    // A pathological frame (a layout run moving every node) must not turn into
+    // thousands of spatial queries. Past the cap, collapse to one covering box:
+    // strictly more invalidation, strictly less bookkeeping.
+    if (boxes.length > maxBoxes) {
+        let minX = Infinity;
+        let minY = Infinity;
+        let maxX = -Infinity;
+        let maxY = -Infinity;
+        for (const b of boxes) {
+            minX = Math.min(minX, b.x);
+            minY = Math.min(minY, b.y);
+            maxX = Math.max(maxX, b.x + b.width);
+            maxY = Math.max(maxY, b.y + b.height);
+        }
+        return [{ x: minX, y: minY, width: maxX - minX, height: maxY - minY }];
+    }
+    return boxes;
+}
+//# sourceMappingURL=route-memo.js.map

package/src/libs/renderer/src/svg/route-solver-bridge.d.ts

@@ -0,0 +1,48 @@
+import type { SolverEdge, SolverOptions, SolverPort, Obstacle, RoutedPath } from '@grafloria/engine';
+export interface RouteSolverBridgeOptions {
+    /**
+     * A real Worker (or anything satisfying SolverPort). Omit to run the solver
+     * INLINE — same protocol, same code, same answers, just on this thread. The
+     * bridge does not construct a Worker itself: that would bake one bundler's URL
+     * scheme into the renderer, which is the mistake the old LayoutWorkerPool made.
+     */
+    port?: SolverPort;
+    solver?: SolverOptions;
+    /** "I have better routes than the ones you painted." Ask for a re-render. */
+    onRoutesReady?: () => void;
+}
+export interface RouteSolverStats {
+    submitted: number;
+    applied: number;
+    /** answers thrown away because the world had moved on under them */
+    discarded: number;
+    superseded: number;
+}
+export declare class RouteSolverBridge {
+    private readonly host;
+    private readonly options?;
+    private readonly onRoutesReady?;
+    /** The solver's latest accepted answer, and the world it describes. */
+    private routes;
+    private routesVersion;
+    private inFlightVersion;
+    private queued;
+    private _stats;
+    private disposed;
+    constructor(options?: RouteSolverBridgeOptions);
+    get stats(): Readonly<RouteSolverStats>;
+    /** True once the solver has an answer for THIS world — i.e. one safe to paint. */
+    hasRoutesFor(version: number): boolean;
+    routeFor(linkId: string, version: number): RoutedPath | undefined;
+    /**
+     * Ask for this world to be solved. Idempotent per version: submitting the same
+     * world twice does nothing, so calling this every frame is free.
+     *
+     * If a solve is already running for an older world, the new one is QUEUED, not
+     * raced — and if a third arrives first, it replaces the queued one. At most one
+     * solve in flight, and the newest world always wins.
+     */
+    submit(version: number, edges: SolverEdge[], obstacles: Obstacle[]): void;
+    private dispatch;
+    dispose(): void;
+}

package/src/libs/renderer/src/svg/route-solver-bridge.js

@@ -0,0 +1,151 @@
+"use strict";
+// Wave 8 (Performance & scale) — Card 6: the render loop finally drives the solver.
+//
+// Wave 5 (Card 7) built `GlobalRouteSolver` — all edges routed against ONE shared
+// penalty field, so an edge pays for crossing another edge or crowding a corridor
+// at ROUTING time — and `SolverHost`, the worker seam, whose inline fallback
+// speaks the identical protocol. And then it wrote, honestly, in its own notes:
+// "the render loop does not yet drive the solver." This is that wire.
+//
+// THE CONSTRAINT THAT DICTATES THE ARCHITECTURE. `render()` is SYNCHRONOUS: it
+// returns a VNode tree, and every link's geometry must be final before it does.
+// A worker cannot be awaited from inside it. There is no clever way around this;
+// Wave 7's layout-host learned the neighbouring version of the same lesson the
+// hard way (a worker running a synchronous loop is not reading its message queue,
+// so it cannot even RECEIVE the cancel you sent it).
+//
+// So the wiring is PROVISIONAL-THEN-REFINED, which is what libavoid-class systems
+// do and the only thing that is actually sound here:
+//
+//   1. the synchronous incremental router paints immediately — it is correct, and
+//      after this card it is also fast (a one-node drag at 10k nodes is ~90ms);
+//   2. the global solver runs OFF THE MAIN THREAD against the same world;
+//   3. when its answer lands it is adopted, and a re-render is requested.
+//
+// THE BUG THIS MUST NOT HAVE, and the reason for every `version` below: an answer
+// that arrives after the world has moved was computed against an obstacle set that
+// no longer exists. Painting it puts links through nodes. So every submission
+// carries the world version it was computed for, and a result whose version is no
+// longer current is DISCARDED, not adopted. Late is fine. Wrong is not.
+//
+// And we never try to CANCEL an in-flight solve — see the layout-host note above,
+// it does not work. We SUPERSEDE: the newest world wins, and at most one solve is
+// ever in flight.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouteSolverBridge = void 0;
+const engine_1 = require("@grafloria/engine");
+class RouteSolverBridge {
+    constructor(options = {}) {
+        /** The solver's latest accepted answer, and the world it describes. */
+        this.routes = new Map();
+        this.routesVersion = -1;
+        this.inFlightVersion = -1;
+        this.queued = null;
+        this._stats = { submitted: 0, applied: 0, discarded: 0, superseded: 0 };
+        this.disposed = false;
+        this.host = new engine_1.SolverHost(options.port);
+        this.options = options.solver;
+        this.onRoutesReady = options.onRoutesReady;
+    }
+    get stats() {
+        return this._stats;
+    }
+    /** True once the solver has an answer for THIS world — i.e. one safe to paint. */
+    hasRoutesFor(version) {
+        return this.routesVersion === version && this.routes.size > 0;
+    }
+    routeFor(linkId, version) {
+        if (this.routesVersion !== version)
+            return undefined;
+        return this.routes.get(linkId);
+    }
+    /**
+     * Ask for this world to be solved. Idempotent per version: submitting the same
+     * world twice does nothing, so calling this every frame is free.
+     *
+     * If a solve is already running for an older world, the new one is QUEUED, not
+     * raced — and if a third arrives first, it replaces the queued one. At most one
+     * solve in flight, and the newest world always wins.
+     */
+    submit(version, edges, obstacles) {
+        if (this.disposed)
+            return;
+        if (version === this.routesVersion)
+            return; // already solved
+        if (version === this.inFlightVersion)
+            return; // already solving
+        if (this.inFlightVersion >= 0) {
+            if (this.queued)
+                this._stats.superseded++;
+            this.queued = { version, edges, obstacles };
+            return;
+        }
+        this.dispatch({ version, edges, obstacles });
+    }
+    dispatch(job) {
+        this.inFlightVersion = job.version;
+        this._stats.submitted++;
+        this.host
+            .solve(job.edges, job.obstacles, this.options)
+            .then(({ routes }) => {
+            var _a;
+            if (this.disposed)
+                return;
+            this.inFlightVersion = -1;
+            // The world may have moved while we were solving. If it did, this answer
+            // describes obstacles that are no longer where they were — it is not
+            // "slightly out of date", it is wrong, and painting it would run links
+            // through nodes. Drop it; the queued job below is already solving the
+            // world as it now is.
+            const stillCurrent = this.queued === null || this.queued.version === job.version;
+            if (!stillCurrent) {
+                this._stats.discarded++;
+            }
+            else {
+                this.routes = new Map();
+                for (const [id, points] of routes) {
+                    if (points.length < 2)
+                        continue;
+                    this.routes.set(id, toRoutedPath(points));
+                }
+                this.routesVersion = job.version;
+                this._stats.applied++;
+            }
+            const next = this.queued;
+            this.queued = null;
+            if (next)
+                this.dispatch(next);
+            else if (stillCurrent)
+                (_a = this.onRoutesReady) === null || _a === void 0 ? void 0 : _a.call(this);
+        })
+            .catch(() => {
+            // A solver that throws must not wedge the bridge: the sync router is
+            // already painting correct geometry, so the worst case here is that we
+            // never refine. Reset and let the next frame try again.
+            this.inFlightVersion = -1;
+            const next = this.queued;
+            this.queued = null;
+            if (next)
+                this.dispatch(next);
+        });
+    }
+    dispose() {
+        this.disposed = true;
+        this.routes.clear();
+        this.queued = null;
+    }
+}
+exports.RouteSolverBridge = RouteSolverBridge;
+function toRoutedPath(points) {
+    let totalLength = 0;
+    for (let i = 1; i < points.length; i++) {
+        totalLength += Math.abs(points[i].x - points[i - 1].x) + Math.abs(points[i].y - points[i - 1].y);
+    }
+    return {
+        points: points.map((p) => ({ x: p.x, y: p.y })),
+        totalLength,
+        bendCount: Math.max(0, points.length - 2),
+        cost: totalLength,
+    };
+}
+//# sourceMappingURL=route-solver-bridge.js.map

package/src/libs/renderer/src/svg/shape-registry.d.ts

@@ -0,0 +1,189 @@
+import type { VNode, VNodeType } from '../types';
+import { type PathViewBox } from './path-outline';
+export type ShapeSide = 'left' | 'right' | 'top' | 'bottom';
+export interface ShapePoint {
+    x: number;
+    y: number;
+}
+/** Node bounding box in WORLD coordinates (used by boundaryPoint). */
+export interface ShapeRect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/**
+ * Transform applied to a shape outline. The same primitive drives every render
+ * site: body = {}, selection = { grow: padding }, shadow = { dx, dy }.
+ */
+export interface OutlineTransform {
+    /** Expand the outline outward by this many px (selection highlight padding). */
+    grow?: number;
+    /** Translate the outline (drop-shadow offset). */
+    dx?: number;
+    dy?: number;
+    /** Corner radius for rect (rx). Emitted only when truthy unless `radiusAlways`. */
+    radius?: number;
+    /** Also emit ry (= radius). Selection/body want rx+ry; shadow wants rx only. */
+    radiusY?: boolean;
+    /** Emit rx even when `radius` is 0 (shadow keeps rx: borderRadius ?? 4). */
+    radiusAlways?: boolean;
+}
+/** An SVG element type plus the geometry props for one outline instance. */
+export interface OutlineSpec {
+    el: VNodeType;
+    geom: Record<string, number | string>;
+    /** Polygon shapes expose their vertices so boundaryPoint can reuse them. */
+    verts?: ShapePoint[];
+}
+/**
+ * A shape's inner label box in LOCAL coordinates (0,0 = node top-left). The
+ * node label engine wraps + clips text to this rect. Curved / slanted shapes
+ * (diamond, ellipse, triangle, cylinder …) inset it so text stays inside the
+ * visible silhouette. See {@link getInnerRect}.
+ */
+export interface InnerRect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/**
+ * The single geometry contract every node shape implements. Register once via
+ * {@link registerShape} and the shape works across body, selection, shadow,
+ * smart-connection boundary and port positioning — no switch edits required.
+ */
+export interface ShapeDefinition {
+    type: string;
+    /** Outline geometry under a transform (drives body + selection + shadow). */
+    outline(width: number, height: number, transform?: OutlineTransform): OutlineSpec;
+    /**
+     * Point on the outline for a floating smart-connection attachment on `side`
+     * at cross-axis coordinate `cross` (world coords). Return null to fall back
+     * to the bounding-box edge (rect and unknown shapes do this).
+     */
+    boundaryPoint(rect: ShapeRect, side: ShapeSide, cross: number): ShapePoint | null;
+    /** Local-space port anchor on `side` for port `rank` of `count` on that side. */
+    portAnchor(width: number, height: number, side: ShapeSide, rank: number, count: number): ShapePoint;
+    /**
+     * The label box in local coords (0,0 = top-left). Used by the node label
+     * engine to wrap, clip and ellipsis-truncate text inside the silhouette.
+     * Optional — omit to accept the padded-bbox default ({@link defaultInnerRect}).
+     */
+    innerRect?(width: number, height: number): InnerRect;
+    /** How the node body applies node styles. Defaults to 'inline'. */
+    styleMode?: 'inline' | 'spread';
+    /** Style keys dropped from the body's pass-through props (circle: rx, ry). */
+    bodyStripKeys?: string[];
+    /**
+     * Geometry keys emitted AFTER the pass-through props in the body, so an
+     * explicit value overrides one arriving via the styles object. rect defers
+     * rx/ry so an explicit cornerRadius wins over a themed borderRadius.
+     */
+    bodyDeferGeomKeys?: string[];
+}
+/**
+ * Register (or replace) a shape definition. This is the payoff: a new shape is
+ * added in ONE place and immediately works across body/selection/shadow,
+ * smart-connection boundaries and port positioning — no switch edits.
+ */
+export declare function registerShape(type: string, def: Omit<ShapeDefinition, 'type'> & {
+    type?: string;
+}): void;
+/**
+ * A static SVG path string, or a parametric generator that returns the path `d`
+ * for a specific `width × height` box (0,0 at top-left). The generator form is
+ * preferred for shapes whose detail should NOT scale uniformly (rounded corners,
+ * fixed-radius notches); the static form is the quickest way to drop in a figure
+ * authored in a design tool.
+ */
+export type PathGeometry = string | ((width: number, height: number) => string);
+/**
+ * Options for {@link registerPathShape}.
+ *
+ * By default the boundary point (smart-connection attachment) and the port
+ * anchors are DERIVED from the path outline by sampling — so a custom silhouette
+ * attaches links to its real edge, not its bounding box. Supply `portAnchor` /
+ * `boundaryPoint` to override the sampled geometry with exact analytic anchors
+ * (the same override seam the built-in triangle uses for its apex/base points).
+ */
+export interface PathShapeOptions {
+    /** Reference box for a STATIC path string (default `0 0 1 1` — unit box). */
+    viewBox?: PathViewBox;
+    /** Exact port anchors, bypassing outline sampling. */
+    portAnchor?: ShapeDefinition['portAnchor'];
+    /** Exact smart-connection boundary, bypassing outline sampling. */
+    boundaryPoint?: ShapeDefinition['boundaryPoint'];
+    /** Label box; defaults to the padded bounding box. */
+    innerRect?: ShapeDefinition['innerRect'];
+    /** Curve subdivision when sampling the outline (default 24). */
+    sampleSteps?: number;
+}
+/**
+ * Register an arbitrary SVG-path shape (Card 2). This is the payoff of the
+ * geometry contract: a userland caller adds a brand-new silhouette in ONE call
+ * and it works everywhere the built-ins do — node body, selection highlight,
+ * drop shadow, smart-connection boundary and geometry-true port anchors — with
+ * NO core-team switch edits.
+ *
+ * ```ts
+ * // Parametric — a 5-point star that fills any box.
+ * registerPathShape('star', (w, h) => starPath(w, h));
+ * // Static — a chevron authored in a 24×24 art box.
+ * registerPathShape('chevron', 'M2,4 L14,4 L22,12 L14,20 L2,20 L10,12 Z',
+ *   { viewBox: { x: 0, y: 0, w: 24, h: 24 } });
+ * ```
+ */
+export declare function registerPathShape(type: string, path: PathGeometry, opts?: PathShapeOptions): void;
+/**
+ * BUILD a path shape's definition without storing it anywhere.
+ *
+ * Extracted from {@link registerPathShape} so a PER-DIAGRAM registry can offer
+ * `registerPathShape` too. Everything expensive and everything subtle — path
+ * parsing, the one-slot outline sample memo, the derived boundary and port
+ * anchors — lives here, so the global and scoped paths cannot drift into
+ * producing different geometry for the same path.
+ */
+export declare function buildPathShapeDefinition(type: string, path: PathGeometry, opts?: PathShapeOptions): ShapeDefinition;
+/**
+ * The rect shape is the default fallback for unknown / unset shape types.
+ *
+ * Resolution order is DIAGRAM-FIRST, then process-global. A diagram that
+ * contributed its own `badge` sees its own; every other diagram — and this one,
+ * for every name it did not claim — still sees the global registry. See
+ * `ext/registry-scope.ts` for why the lookup is ambient rather than threaded.
+ */
+export declare function getShape(type: string | undefined): ShapeDefinition;
+/** Whether a shape type is registered (excludes the implicit rect fallback). */
+export declare function hasShape(type: string): boolean;
+/** All registered shape type names (built-ins + extended library + aliases). */
+export declare function listShapes(): string[];
+/** Remove a registered shape. Returns false when the type was not registered. */
+export declare function unregisterShape(type: string): boolean;
+/**
+ * Snapshot the current catalogue, so a caller can restore it later. Used by the
+ * ExtensionHost to give a scoped extension an exact "undo" even when it OVERWROTE
+ * an existing shape rather than adding a new one.
+ */
+export declare function getShapeDefinition(type: string): ShapeDefinition | undefined;
+/**
+ * Monotonic counter, incremented on every add/remove. Cheap cache key.
+ * NOTE: `registerShape` itself bumps it — see the wrapper installed below.
+ */
+export declare function getShapeRegistryVersion(): number;
+/** Subscribe to catalogue changes. Returns a disposer. */
+export declare function onShapeRegistryChange(listener: () => void): () => void;
+/** Internal: let `registerShape` participate in the version/notify protocol. */
+export declare function notifyShapeRegistered(): void;
+/**
+ * The label box for a shape in local coords. Falls back to a padded bounding
+ * box when the shape doesn't override `innerRect`.
+ */
+export declare function getInnerRect(def: ShapeDefinition, width: number, height: number): InnerRect;
+/** Padded-bbox label box: inset by up to 8px, clamped so it never inverts. */
+export declare function defaultInnerRect(width: number, height: number): InnerRect;
+export declare function buildShapeBody(def: ShapeDefinition, width: number, height: number, cornerRadius: number | undefined, styles: any): VNode;
+/** Selection-highlight VNode: the outline grown by `padding`, plus baseProps. */
+export declare function buildShapeSelection(def: ShapeDefinition, width: number, height: number, padding: number, baseProps: Record<string, any>): VNode;
+/** Drop-shadow VNode: the outline offset by (offset, offset), plus baseProps. */
+export declare function buildShapeShadow(def: ShapeDefinition, width: number, height: number, offset: number, borderRadius: number, baseProps: Record<string, any>): VNode;