@grafloria/element 0.3.20 → 0.3.22

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

@@ -1,206 +0,0 @@
-"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

@@ -1,48 +0,0 @@
-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

@@ -1,151 +0,0 @@
-"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

@@ -1,189 +0,0 @@
-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;