@grafloria/element 0.3.19 → 0.3.21

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

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

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

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

@@ -1,109 +0,0 @@
-/**
- * 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

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

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

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

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

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

@@ -1,9 +0,0 @@
-/**
- * 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;