@grafloria/element 0.3.18 → 0.3.19

package/src/libs/engine/src/types/model.types.d.ts

@@ -0,0 +1,378 @@
+export interface SerializedEntity {
+    id: string;
+    uuid: string;
+    type: string;
+    version: number;
+    metadata: Record<string, any>;
+}
+export interface NodeState {
+    visible: boolean;
+    locked: boolean;
+    selected: boolean;
+    hovered: boolean;
+    /**
+     * Draw attention to the node without selecting it (search hits, traversal
+     * highlights, "related" emphasis). Independent of `selected`; when both are
+     * set, `selected` wins in the renderer's state precedence.
+     */
+    highlighted?: boolean;
+    focused: boolean;
+    expanded: boolean;
+    enabled: boolean;
+    error?: string;
+    warning?: string;
+    status?: 'idle' | 'pending' | 'running' | 'completed' | 'error' | 'warning';
+    animateStatus?: boolean;
+}
+export interface NodeBehavior {
+    selectable: boolean;
+    draggable: boolean;
+    resizable: boolean;
+    rotatable: boolean;
+    deletable: boolean;
+    editable: boolean;
+    connectable: boolean;
+    groupable: boolean;
+    cloneable: boolean;
+    dragHandler?: {
+        isDragHandler: boolean;
+        dragChildren?: boolean;
+    };
+}
+export interface NodeStyle {
+    shape?: string;
+    /**
+     * Extra CSS class(es) put verbatim on the rendered element, alongside
+     * `diagram-node` and the state classes. Purely a hook for host CSS — the
+     * renderer never reads it back (React Flow's "className on every element").
+     */
+    className?: string;
+    /**
+     * Name(s) of NAMED STYLES to apply — the classDef / linkStyle equivalent.
+     * Space-separated (`'critical dashed'`, later names win). Defined with
+     * `defineStyle(name, style)` and resolved by the renderer's cascade:
+     *   theme < type-default < named-class < element-inline < state
+     * so an own property on this style object always beats the named style.
+     */
+    styleClass?: string;
+    fill?: string | LinearGradient | RadialGradient | Pattern;
+    stroke?: string | LinearGradient | RadialGradient | Pattern;
+    strokeWidth?: number;
+    strokeDasharray?: string;
+    opacity?: number;
+    shadow?: boolean | Shadow;
+    borderRadius?: number;
+    fontSize?: number;
+    fontFamily?: string;
+    fontWeight?: string;
+    fontStyle?: string;
+    textDecoration?: string;
+    color?: string;
+    padding?: number;
+    zIndex?: number;
+    animatedBorder?: boolean;
+    borderAnimationType?: 'gradient' | 'pulse' | 'breathe' | 'shimmer' | 'none';
+    borderAnimationSpeed?: number;
+    borderAnimationColors?: string[];
+}
+export interface PortPosition {
+    x: number;
+    y: number;
+}
+export interface PortAlignment {
+    side: 'left' | 'right' | 'top' | 'bottom';
+    offset: number;
+}
+export interface LinkState {
+    selected: boolean;
+    hovered: boolean;
+    highlighted: boolean;
+    animated?: boolean;
+}
+export interface JumpPointConfig {
+    enabled: boolean;
+    size?: number;
+    style?: 'arc' | 'gap' | 'bridge';
+    detectMode?: 'all' | 'perpendicular' | 'threshold';
+    threshold?: number;
+}
+export interface LinkStyle {
+    /**
+     * Extra CSS class(es) put verbatim on the rendered path, alongside
+     * `diagram-link` and the state classes. Host-CSS hook; never read back.
+     */
+    className?: string;
+    /**
+     * Name(s) of NAMED STYLES to apply — the classDef / linkStyle equivalent.
+     * Space-separated (later names win). See NodeStyle.styleClass; identical
+     * cascade: theme < type-default < named-class < element-inline < state.
+     */
+    styleClass?: string;
+    stroke?: string | LinearGradient | RadialGradient | Pattern;
+    strokeWidth?: number;
+    strokeDasharray?: string;
+    opacity?: number;
+    arrowHead?: ArrowStyle;
+    arrowTail?: ArrowStyle;
+    /**
+     * Wave 3 (Edges & links): smooth/bezier curve TIGHTNESS, as a multiplier of
+     * the endpoint distance for the control-point offset. Default `0.5`
+     * (unchanged legacy behaviour); `0` collapses the curve onto its chord,
+     * larger values bulge harder. Honoured by both LinkModel.generateSmoothPath
+     * and the SVG renderer's control-point maths, so a link looks the same
+     * however its path was produced.
+     */
+    curvature?: number;
+    /**
+     * Wave 5 (Edge routing) — Card 1. Minimum port-anchor stub (px): the route
+     * leaves the source and enters the target perpendicular to the port side for
+     * at least this length before the first bend — GUARANTEED, not best-effort
+     * (the router enforces it on whichever routing branch produced the path).
+     * Unset = the legacy 20px best-effort stub, byte-for-byte.
+     */
+    jetty?: number;
+    /**
+     * Wave 3 (Edges & links): PER-LINK orthogonal corner radius (px). Defaults to
+     * the renderer's built-ins (5px for `orthogonal`, 12px for the rounded
+     * fallback a `smooth` detour falls back to). `0` gives hard 90° corners.
+     *
+     * Safe at any size: every bend is clamped to half the shorter adjacent
+     * segment. When the link also draws jump points, the radius is additionally
+     * clamped (never below the built-in default) so the jump arcs keep a legal
+     * window clear of the corners — jumps win over an oversized radius.
+     */
+    cornerRadius?: number;
+    jumpPoints?: JumpPointConfig;
+    /**
+     * Wave 4 (Edges & links) — Card 4: how THIS link behaves when it is one of
+     * several links between the same pair of nodes. Per-link override of the
+     * renderer-wide `parallelLinks` config.
+     */
+    parallel?: ParallelLinkConfig;
+    /**
+     * Wave 4 (Edges & links) — Card 4: how THIS link is drawn when it is a
+     * SELF-LOOP (source node === target node). Ignored on ordinary links.
+     */
+    selfLoop?: SelfLoopConfig;
+    /**
+     * Wave 4 (Edges & links) — Card 5: name of a registered LINK TEMPLATE
+     * (`registerLinkTemplate` in @grafloria/renderer). The template replaces the
+     * link's default visuals (path + arrows + labels) with whatever VNodes it
+     * returns — arbitrary SVG, or HTML through a `foreignObject`. The hit area
+     * and the `data-link-id` group are still emitted by the renderer, so hit
+     * testing, selection and the edge toolbar keep working unchanged.
+     *
+     * Deliberately a NAME, not a function: LinkStyle is serializable model state
+     * and the engine must not depend on the renderer's VNode type. Same shape as
+     * `styleClass` → the named-style registry.
+     */
+    template?: string;
+    gradient?: LinearGradient | RadialGradient;
+    pattern?: Pattern;
+    shadow?: Shadow;
+    animation?: LinkAnimation;
+    markers?: Marker[];
+}
+/**
+ * Wave 4 — Card 4: auto-separation of PARALLEL links (two or more links between
+ * the same pair of nodes). Without it, ERD / BPMN / state-machine diagrams stack
+ * every relationship between the same two entities on top of each other.
+ *
+ * The links in a pair are fanned out symmetrically around the un-separated
+ * route: with 2 links and spacing 16 the offsets are -8 and +8; with 3 they are
+ * -16, 0, +16. Direction of the fan is the left/right normal of the source →
+ * target vector, so both directions of a bidirectional pair fan consistently.
+ */
+export interface ParallelLinkConfig {
+    /** Turn separation off for this link (it stays on the un-separated route). */
+    enabled?: boolean;
+    /** Distance between adjacent links in the group, in px. Default 16. */
+    spacing?: number;
+    /**
+     * Extra offset added on top of the computed fan offset (px, signed). Lets an
+     * author nudge one member of a bundle without touching the others.
+     */
+    offset?: number;
+}
+/**
+ * Wave 4 — Card 4: SELF-LOOP geometry (source node === target node). The loop
+ * leaves the source port, bulges away from the node body and re-enters at the
+ * target port. Several self-loops on the same node nest concentrically
+ * (`size + i * spacing`), so each keeps its own label slot.
+ */
+export interface SelfLoopConfig {
+    /** How far the loop bulges away from the node body (px). Default 40. */
+    size?: number;
+    /**
+     * Lateral span of the loop along the node's side (px). Only used when the
+     * source and target attachment points coincide (or nearly do) — the two ends
+     * are spread by this much so the loop has a body. Default = `size`.
+     */
+    width?: number;
+    /** Extra size added per additional self-loop on the same node (px). Default 18. */
+    spacing?: number;
+    /**
+     * Force the side the loop bulges out of. `'auto'` (default) uses the source
+     * port's own side.
+     */
+    side?: 'auto' | 'top' | 'right' | 'bottom' | 'left';
+}
+export interface LinearGradient {
+    type: 'linear';
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    stops: GradientStop[];
+}
+export interface RadialGradient {
+    type: 'radial';
+    cx: number;
+    cy: number;
+    r: number;
+    stops: GradientStop[];
+}
+export interface GradientStop {
+    offset: number;
+    color: string;
+    opacity?: number;
+}
+export interface Pattern {
+    type: 'dots' | 'lines' | 'grid' | 'hatch' | 'crosshatch';
+    color?: string;
+    backgroundColor?: string;
+    size?: number;
+    spacing?: number;
+}
+export interface Shadow {
+    offsetX: number;
+    offsetY: number;
+    blur: number;
+    color: string;
+}
+export interface LinkAnimation {
+    type: 'marching-ants' | 'flow' | 'pulse' | 'dash-flow' | 'none';
+    duration?: number;
+    dashOffset?: number;
+    speed?: 'slow' | 'normal' | 'fast';
+    direction?: 'forward' | 'reverse';
+}
+export interface Marker {
+    type: 'arrow' | 'circle' | 'square' | 'custom';
+    position: number;
+    size?: number;
+    color?: string;
+}
+export interface ArrowStyle {
+    type: 'none' | 'arrow' | 'circle' | 'square' | 'diamond' | 'crow-foot' | 'one' | 'zero-or-one' | 'zero-or-many' | 'one-or-many' | 'hollow-diamond' | 'filled-diamond' | 'generalization' | 'open-arrow' | 'double-arrow' | 'cross' | 'bar' | 'dot' | 'oval' | 'half-arrow-left' | 'half-arrow-right' | 'custom' | (string & {});
+    size: number;
+    filled: boolean;
+    width?: number;
+    offset?: number;
+    color?: string;
+    /**
+     * Wave 4 — Card 5: raw SVG path data for a `type: 'custom'` marker. Drawn in
+     * the marker's LOCAL frame: the origin is the anchor the renderer pulls back
+     * from the endpoint, +x is the direction of travel. Scale it yourself (or
+     * read `size` when you build the string).
+     */
+    path?: string;
+    /**
+     * Wave 4 — Card 5: name of a marker registered via `registerMarker`. Set it
+     * with `type: 'custom'` (or simply put the registered name in `type`).
+     */
+    marker?: string;
+    /**
+     * Wave 4 — Card 5: distance from the custom marker's local origin to its
+     * visual TIP, in the +x direction. The renderer pulls the marker back from
+     * the path endpoint by exactly this much so the tip lands on the port.
+     * Registered markers supply their own default; this overrides it. Default 0
+     * for an unregistered `path` marker (i.e. the tip is at the origin).
+     */
+    tipOffset?: number;
+}
+/**
+ * Wave 4 — Card 5: the three label SLOTS along an edge (ngx-vflow ships exactly
+ * these). A slot is shorthand for a `position`: start = 0.12, center = 0.5,
+ * end = 0.88 — pulled off the very endpoints so a slot label never sits under
+ * an arrowhead. An explicit `position` still wins.
+ */
+export type LinkLabelSlot = 'start' | 'center' | 'end';
+export interface LinkLabel {
+    id: string;
+    text: string;
+    position: number;
+    offset: Point;
+    style?: LabelStyle;
+    rotation?: 'auto' | number;
+    rotationOffset?: number;
+    keepUpright?: boolean;
+    textAnchor?: 'start' | 'middle' | 'end';
+    textBaseline?: 'top' | 'middle' | 'bottom';
+    textWrap?: boolean;
+    maxWidth?: number;
+    /**
+     * Auto-position this label so it does not overlap nodes, other labels or
+     * links. Handled by the diagram-wide edge optimizer (Card 7): `offset` is the
+     * label's PREFERRED placement and the optimizer searches outward from it only
+     * when it collides. Was declared-but-dead until Wave 4.
+     */
+    autoOffset?: boolean;
+    segmentIndex?: number;
+    /**
+     * Wave 4 — Card 5: one of the three edge slots. Shorthand for `position`;
+     * ignored when the label carries an explicit `position` (see LinkLabelSlot).
+     */
+    slot?: LinkLabelSlot;
+    /**
+     * Wave 4 — Card 5: render this label as ARBITRARY HTML inside a
+     * `foreignObject` instead of SVG text. The string is injected verbatim, so it
+     * is the author's job to keep it trusted/escaped — exactly like any
+     * `innerHTML` seam.
+     */
+    html?: string;
+    /**
+     * Wave 4 — Card 5: name of a label template registered with
+     * `registerLabelTemplate` (@grafloria/renderer). The template returns VNodes, so
+     * it can emit SVG or a `foreignObject` full of HTML. Wins over `html`.
+     */
+    template?: string;
+    /** Width of the HTML/template label's box (px). Default 120. */
+    width?: number;
+    /** Height of the HTML/template label's box (px). Default 28. */
+    height?: number;
+}
+export interface LabelStyle {
+    fontSize?: number;
+    fontFamily?: string;
+    color?: string;
+    background?: string;
+    padding?: number;
+    borderRadius?: number;
+    fontWeight?: 'normal' | 'bold' | '100' | '200' | '300' | '400' | '500' | '600' | '700' | '800' | '900';
+    fontStyle?: 'normal' | 'italic' | 'oblique';
+    textDecoration?: 'none' | 'underline' | 'overline' | 'line-through';
+    border?: string;
+    borderWidth?: number;
+    shadow?: Shadow;
+    opacity?: number;
+    lineHeight?: number;
+}
+export interface ValidationResult {
+    valid: boolean;
+    errors: ValidationError[];
+    warnings: ValidationWarning[];
+}
+export interface ValidationError {
+    path: string;
+    message: string;
+    code: string;
+    severity: 'error';
+}
+export interface ValidationWarning {
+    path: string;
+    message: string;
+    code: string;
+    severity: 'warning';
+}
+import { Point } from './geometry.types';

package/src/libs/engine/src/types/model.types.js

@@ -0,0 +1,4 @@
+"use strict";
+// Model type definitions for diagram entities
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=model.types.js.map

package/src/libs/engine/src/types/model.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.types.js","sourceRoot":"","sources":["../../../../../../engine/src/types/model.types.ts"],"names":[],"mappings":";AAAA,8CAA8C"}

package/src/libs/engine/src/types/performance.types.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Level of Detail tier name.
+ *
+ * Widened (wave2/rendering) from the fixed `'high' | 'medium' | 'low'` union to
+ * `string` so apps can register their own tiers through {@link LODConfig}. The
+ * three built-in tiers keep those exact names, so every historical
+ * `lod === 'high'` / `lod !== 'low'` style check keeps working unchanged.
+ */
+export type LODLevel = string;
+/**
+ * A visual feature that a {@link LODTier} may gate on. Renderers ask
+ * `diagram.shouldRender(feature, lod)` instead of hardcoding zoom breakpoints.
+ *
+ * wave8/culling — THE ECONOMIC FEATURES. Everything above the divider gates a
+ * DECORATION: dropping it removes a few attributes or a child VNode at the very
+ * end of the pipeline, and the work that produced them ran anyway. That made LOD
+ * cosmetic, not economic: a 10k-node zoom-out frame took 63 SECONDS because the
+ * renderer was still routing every edge around every obstacle to place lines
+ * whose detours were sub-pixel on screen.
+ *
+ * The three below gate WORK, not paint. They are what makes a far-zoom frame
+ * actually cheap, and they are the reason `LODFeature` is worth having at all.
+ */
+export type LODFeature = 'labels' | 'icons' | 'borders' | 'shadows' | 'ports' | 'decorations' | 'handles'
+/**
+ * Obstacle-aware edge routing and the diagram-wide edge passes that depend on
+ * it (parallel-bundle lanes, corridor nudging). OFF ⇒ every auto-routed edge
+ * is a direct port-to-port polyline, computed in O(1) instead of O(nodes).
+ * This is the single most expensive thing the renderer does.
+ */
+ | 'routing'
+/**
+ * Per-edge path FIDELITY: curve emission, jump-overs, label placement, the
+ * full bend list. OFF ⇒ the drawn polyline is simplified (Douglas–Peucker at
+ * ~1 screen pixel) and the diagram-wide edge optimizer does not run.
+ */
+ | 'link-detail'
+/**
+ * Gradient / pattern paint servers. OFF ⇒ a gradient or pattern fill collapses
+ * to a flat representative colour, which also lets the entity back into the
+ * VNode cache (paint-server entities bypass it — see `nodeUsesPaintServer`).
+ */
+ | 'gradients';
+/** Every feature, in a stable order. Handy for "render everything" tiers. */
+export declare const ALL_LOD_FEATURES: readonly LODFeature[];
+/**
+ * One rung of a Level-of-Detail policy.
+ */
+export interface LODTier {
+    /** Tier name — returned by `getLODLevel()` and used as the render LOD key. */
+    name: string;
+    /**
+     * Inclusive lower zoom bound. The active tier for a given zoom is the
+     * highest-`minZoom` tier whose `minZoom <= zoom`.
+     */
+    minZoom: number;
+    /** The set of features that render at this tier. */
+    features: Set<LODFeature>;
+}
+/**
+ * A declarative, per-diagram Level-of-Detail policy. Replaces the hardcoded
+ * zoom breakpoints and per-tier feature gates that used to live inside
+ * DiagramModel.
+ */
+export interface LODConfig {
+    tiers: LODTier[];
+}
+/**
+ * Build the default 3-tier LOD policy.
+ *
+ * ```
+ *   zoom >= 1.0        -> 'high'   (everything)
+ *   0.5 <= zoom < 1.0  -> 'medium' (labels, borders, ports, decorations, handles,
+ *                                   + routing, link-detail, gradients)
+ *   zoom <  0.5        -> 'low'    (nothing — plain rects and direct lines)
+ * ```
+ *
+ * wave8/culling — THE MEDIUM/LOW BREAKPOINT MOVED, 0.2 → 0.5, and that is the
+ * behaviour change in this wave.
+ *
+ * The old boundary made 'medium' span 0.2–1.0 with a near-full feature set, so a
+ * diagram at 0.25 zoom — the zoom fit-to-content lands on for anything large —
+ * still measured every label, drew every port, and routed every edge around every
+ * obstacle. It was the far view that was expensive: 63 SECONDS for one 10k-node
+ * frame, against 124ms for the near view. LOD had breakpoints but no economics.
+ *
+ * Each breakpoint is now set where the DETAIL STOPS BEING LEGIBLE, not where it
+ * stops being cheap — the theme's 12px label is 6px at 0.5 zoom and 3px at 0.25,
+ * and a port glyph is under a pixel. Zooms in [0.5, 1.0) render exactly as they
+ * always have. [0.2, 0.5) is 'sketch': text and chrome go (they are unreadable),
+ * the graph's SHAPE stays (it is not). Below 0.2, everything goes.
+ *
+ * Cost is deliberately NOT a factor in these numbers, because it cannot be: the
+ * same zoom is cheap for 30 nodes and ruinous for 10,000, and a constant chosen
+ * here would either tax the small diagram or fail to save the large one. That is
+ * the quality governor's job — it measures the frame and steps the tier down on
+ * the scenes and machines that need it. Perception picks the tier; measurement
+ * decides whether you can afford it.
+ *
+ * Fresh `Set`s are created per call so no two diagrams share mutable state.
+ */
+export declare function createDefaultLODConfig(): LODConfig;
+/**
+ * Entity with Level of Detail information
+ */
+export interface EntityWithLOD<T> {
+    entity: T;
+    lod: LODLevel;
+}

package/src/libs/engine/src/types/performance.types.js

@@ -0,0 +1,122 @@
+"use strict";
+// performance.types.ts - Types for performance optimizations (Phase 5.3)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALL_LOD_FEATURES = void 0;
+exports.createDefaultLODConfig = createDefaultLODConfig;
+/** Every feature, in a stable order. Handy for "render everything" tiers. */
+exports.ALL_LOD_FEATURES = [
+    'labels',
+    'icons',
+    'borders',
+    'shadows',
+    'ports',
+    'decorations',
+    'handles',
+    'routing',
+    'link-detail',
+    'gradients',
+];
+/**
+ * Build the default 3-tier LOD policy.
+ *
+ * ```
+ *   zoom >= 1.0        -> 'high'   (everything)
+ *   0.5 <= zoom < 1.0  -> 'medium' (labels, borders, ports, decorations, handles,
+ *                                   + routing, link-detail, gradients)
+ *   zoom <  0.5        -> 'low'    (nothing — plain rects and direct lines)
+ * ```
+ *
+ * wave8/culling — THE MEDIUM/LOW BREAKPOINT MOVED, 0.2 → 0.5, and that is the
+ * behaviour change in this wave.
+ *
+ * The old boundary made 'medium' span 0.2–1.0 with a near-full feature set, so a
+ * diagram at 0.25 zoom — the zoom fit-to-content lands on for anything large —
+ * still measured every label, drew every port, and routed every edge around every
+ * obstacle. It was the far view that was expensive: 63 SECONDS for one 10k-node
+ * frame, against 124ms for the near view. LOD had breakpoints but no economics.
+ *
+ * Each breakpoint is now set where the DETAIL STOPS BEING LEGIBLE, not where it
+ * stops being cheap — the theme's 12px label is 6px at 0.5 zoom and 3px at 0.25,
+ * and a port glyph is under a pixel. Zooms in [0.5, 1.0) render exactly as they
+ * always have. [0.2, 0.5) is 'sketch': text and chrome go (they are unreadable),
+ * the graph's SHAPE stays (it is not). Below 0.2, everything goes.
+ *
+ * Cost is deliberately NOT a factor in these numbers, because it cannot be: the
+ * same zoom is cheap for 30 nodes and ruinous for 10,000, and a constant chosen
+ * here would either tax the small diagram or fail to save the large one. That is
+ * the quality governor's job — it measures the frame and steps the tier down on
+ * the scenes and machines that need it. Perception picks the tier; measurement
+ * decides whether you can afford it.
+ *
+ * Fresh `Set`s are created per call so no two diagrams share mutable state.
+ */
+function createDefaultLODConfig() {
+    return {
+        tiers: [
+            {
+                name: 'high',
+                minZoom: 1.0,
+                features: new Set(exports.ALL_LOD_FEATURES),
+            },
+            {
+                name: 'medium',
+                minZoom: 0.5,
+                features: new Set([
+                    'labels',
+                    'borders',
+                    'ports',
+                    'decorations',
+                    'handles',
+                    // The economic features are ON here: everything from 0.5 up routes,
+                    // curves and gradients exactly as it always has.
+                    'routing',
+                    'link-detail',
+                    'gradients',
+                ]),
+            },
+            {
+                // ---------------------------------------------------------------------
+                // 'sketch' — [0.2, 0.5). THE TIER THAT SEPARATES PERCEPTION FROM COST.
+                // ---------------------------------------------------------------------
+                // At zoom 0.3 a 120x60 node is 36x18 CSS px. A 12px label on it renders at
+                // 3.6px and is not text, it is a grey smear — so labels, ports, handles and
+                // decorations genuinely have nothing to say here, and dropping them costs
+                // the viewer nothing.
+                //
+                // But the LINKS are still perfectly legible at that size, and an orthogonal
+                // route is plainly distinguishable from a straight diagonal. Collapsing
+                // routes here — as this band briefly did, when 'low' started at 0.5 — makes
+                // every diagram visibly snap its edge shapes as you cross a zoom threshold,
+                // and it charges that to a 30-node flowchart that renders in 3ms and has no
+                // performance problem whatsoever.
+                //
+                // That was a COST problem (10k scenes) being solved with a PERCEPTUAL lever
+                // (what the zoom can display), and the two do not line up. Cost is what the
+                // quality governor is for: it measures the frame and biases the tier down on
+                // the machines and scenes that actually need it, so a big scene at 0.3 zoom
+                // still lands in 'low' within three frames while a small one keeps its
+                // routes. Perception decides the tier; measurement decides whether you can
+                // afford it.
+                name: 'sketch',
+                minZoom: 0.2,
+                features: new Set([
+                    'borders',
+                    // The shape of the graph IS the content at this zoom. Keep it.
+                    'routing',
+                    'link-detail',
+                ]),
+            },
+            {
+                name: 'low',
+                // Floor tier: every zoom is >= -Infinity, so this always matches last. Below
+                // 0.2 a node is under 24px wide and an edge is a hairline — the routing
+                // detour around a node body is now genuinely sub-pixel, and this is where
+                // dropping it is free. It is also where the governor parks a scene too big
+                // to draw at any zoom.
+                features: new Set(),
+                minZoom: Number.NEGATIVE_INFINITY,
+            },
+        ],
+    };
+}
+//# sourceMappingURL=performance.types.js.map

package/src/libs/engine/src/types/performance.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"performance.types.js","sourceRoot":"","sources":["../../../../../../engine/src/types/performance.types.ts"],"names":[],"mappings":";AAAA,yEAAyE;;;AAgIzE,wDAoEC;AA5ID,6EAA6E;AAChE,QAAA,gBAAgB,GAA0B;IACrD,QAAQ;IACR,OAAO;IACP,SAAS;IACT,SAAS;IACT,OAAO;IACP,aAAa;IACb,SAAS;IACT,SAAS;IACT,aAAa;IACb,WAAW;CACZ,CAAC;AA0BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,SAAgB,sBAAsB;IACpC,OAAO;QACL,KAAK,EAAE;YACL;gBACE,IAAI,EAAE,MAAM;gBACZ,OAAO,EAAE,GAAG;gBACZ,QAAQ,EAAE,IAAI,GAAG,CAAa,wBAAgB,CAAC;aAChD;YACD;gBACE,IAAI,EAAE,QAAQ;gBACd,OAAO,EAAE,GAAG;gBACZ,QAAQ,EAAE,IAAI,GAAG,CAAa;oBAC5B,QAAQ;oBACR,SAAS;oBACT,OAAO;oBACP,aAAa;oBACb,SAAS;oBACT,oEAAoE;oBACpE,iDAAiD;oBACjD,SAAS;oBACT,aAAa;oBACb,WAAW;iBACZ,CAAC;aACH;YACD;gBACE,wEAAwE;gBACxE,uEAAuE;gBACvE,wEAAwE;gBACxE,2EAA2E;gBAC3E,4EAA4E;gBAC5E,0EAA0E;gBAC1E,sBAAsB;gBACtB,EAAE;gBACF,4EAA4E;gBAC5E,wEAAwE;gBACxE,4EAA4E;gBAC5E,4EAA4E;gBAC5E,4EAA4E;gBAC5E,kCAAkC;gBAClC,EAAE;gBACF,4EAA4E;gBAC5E,4EAA4E;gBAC5E,6EAA6E;gBAC7E,4EAA4E;gBAC5E,uEAAuE;gBACvE,2EAA2E;gBAC3E,aAAa;gBACb,IAAI,EAAE,QAAQ;gBACd,OAAO,EAAE,GAAG;gBACZ,QAAQ,EAAE,IAAI,GAAG,CAAa;oBAC5B,SAAS;oBACT,+DAA+D;oBAC/D,SAAS;oBACT,aAAa;iBACd,CAAC;aACH;YACD;gBACE,IAAI,EAAE,KAAK;gBACX,6EAA6E;gBAC7E,wEAAwE;gBACxE,0EAA0E;gBAC1E,2EAA2E;gBAC3E,uBAAuB;gBACvB,QAAQ,EAAE,IAAI,GAAG,EAAc;gBAC/B,OAAO,EAAE,MAAM,CAAC,iBAAiB;aAClC;SACF;KACF,CAAC;AACJ,CAAC"}

package/src/libs/engine/src/types/plugin.types.d.ts

@@ -0,0 +1,30 @@
+export interface PluginMetadata {
+    name: string;
+    version: string;
+    author?: string;
+    description?: string;
+    dependencies?: string[];
+}
+export interface PluginContext {
+    engine: any;
+    eventBus: any;
+    config: Record<string, any>;
+}
+export interface Plugin {
+    metadata: PluginMetadata;
+    install(context: PluginContext): void | Promise<void>;
+    uninstall?(context: PluginContext): void | Promise<void>;
+    onActivate?(context: PluginContext): void;
+    onDeactivate?(context: PluginContext): void;
+}
+export interface PluginConfig {
+    enabled: boolean;
+    config?: Record<string, any>;
+}
+export interface PluginRegistry {
+    register(plugin: Plugin): void;
+    unregister(pluginName: string): void;
+    get(pluginName: string): Plugin | undefined;
+    has(pluginName: string): boolean;
+    list(): PluginMetadata[];
+}

package/src/libs/engine/src/types/plugin.types.js

@@ -0,0 +1,4 @@
+"use strict";
+// Plugin system type definitions
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=plugin.types.js.map

package/src/libs/engine/src/types/plugin.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.types.js","sourceRoot":"","sources":["../../../../../../engine/src/types/plugin.types.ts"],"names":[],"mappings":";AAAA,iCAAiC"}

package/src/libs/engine/src/utils/deep-clone.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Deep clone an object with circular reference handling
+ * Handles dates, arrays, maps, sets, plain objects, and circular references
+ */
+export declare function deepClone<T>(value: T, visited?: WeakMap<any, any>): T;
+/**
+ * Check if two values are deeply equal
+ */
+export declare function deepEqual(a: any, b: any): boolean;