@tldiagram/core-ui 1.87.0

package/dist/components/NodeContainer.d.ts

@@ -0,0 +1,8 @@
+import { BoxProps } from '@chakra-ui/react';
+export interface ElementContainerProps extends BoxProps {
+    isSelected?: boolean;
+    isSource?: boolean;
+    isTarget?: boolean;
+    isConnectorHighlighted?: boolean;
+}
+export declare const ElementContainer: import("react").MemoExoticComponent<import("@chakra-ui/react").ComponentWithAs<"div", ElementContainerProps>>;

package/dist/components/NodeHoverCard.d.ts

@@ -0,0 +1,10 @@
+import { type PlacedElement } from '../types';
+interface Props {
+    data: PlacedElement & {
+        hasChildLink?: boolean;
+    };
+    /** Bounding rect of the node element in screen (viewport) coordinates */
+    anchorRect: DOMRect;
+}
+export default function NodeHoverCard({ data, anchorRect }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/PanelHeader.d.ts

@@ -0,0 +1,8 @@
+import type { ReactNode } from 'react';
+interface Props {
+    title: ReactNode;
+    onClose?: () => void;
+    hasCloseButton?: boolean;
+}
+export default function PanelHeader({ title, onClose, hasCloseButton }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/PanelUI.d.ts

@@ -0,0 +1,3 @@
+export declare function KbdHint({ children }: {
+    children: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/ProxyConnectorEdge.d.ts

@@ -0,0 +1,4 @@
+import { type EdgeProps } from 'reactflow';
+declare function ProxyConnectorEdge({ id, source, target, selected, style }: EdgeProps): import("react/jsx-runtime").JSX.Element | null;
+declare const _default: import("react").MemoExoticComponent<typeof ProxyConnectorEdge>;
+export default _default;

package/dist/components/ProxyConnectorPanel.d.ts

@@ -0,0 +1,9 @@
+import type { ProxyConnectorDetails } from '../crossBranch/types';
+interface Props {
+    isOpen: boolean;
+    onClose: () => void;
+    details: ProxyConnectorDetails | null;
+    hasBackdrop?: boolean;
+}
+export default function ProxyConnectorPanel({ isOpen, onClose, details, hasBackdrop, }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/SafeBackground.d.ts

@@ -0,0 +1,13 @@
+import { type ComponentPropsWithoutRef } from 'react';
+import { Background } from 'reactflow';
+/**
+ * Guards React Flow's Background against NaN zoom.
+ *
+ * In @reactflow/background, `scaledSize = patternSize * transform[2]` has no
+ * NaN guard (unlike scaledGap which uses `|| 1`). When d3-zoom produces a NaN
+ * transform during fitView on a zero-size container, scaledSize becomes NaN,
+ * propagating to patternOffset and the circle cx/cy attributes.
+ *
+ * This wrapper simply skips rendering until zoom is a positive finite number.
+ */
+export declare function SafeBackground(props: ComponentPropsWithoutRef<typeof Background>): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/ScrollIndicatorWrapper.d.ts

@@ -0,0 +1,8 @@
+import { type BoxProps } from '@chakra-ui/react';
+import { type ReactNode } from 'react';
+interface ScrollIndicatorWrapperProps extends BoxProps {
+    children: ReactNode;
+    scrollId?: string;
+}
+declare const ScrollIndicatorWrapper: import("react").ForwardRefExoticComponent<ScrollIndicatorWrapperProps & import("react").RefAttributes<HTMLDivElement>>;
+export default ScrollIndicatorWrapper;

package/dist/components/SetChildModal.d.ts

@@ -0,0 +1,10 @@
+import type { ViewTreeNode } from '../types';
+interface Props {
+    isOpen: boolean;
+    onClose: () => void;
+    targetId: number | null;
+    treeData: ViewTreeNode[];
+    onConfirm: (childId: number) => Promise<void>;
+}
+export default function SetChildModal({ isOpen, onClose, targetId, treeData, onConfirm }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/SetParentModal.d.ts

@@ -0,0 +1,10 @@
+import type { ViewTreeNode } from '../types';
+interface Props {
+    isOpen: boolean;
+    onClose: () => void;
+    targetId: number | null;
+    treeData: ViewTreeNode[];
+    onConfirm: (newParentId: number) => Promise<void>;
+}
+export default function SetParentModal({ isOpen, onClose, targetId, treeData, onConfirm }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/SlidingPanel.d.ts

@@ -0,0 +1,16 @@
+import { type ReactNode } from 'react';
+interface Props {
+    isOpen: boolean;
+    onClose: () => void;
+    panelKey: string;
+    side?: 'left' | 'right';
+    width?: string | Record<string, string>;
+    minWidth?: string | Record<string, string>;
+    maxHeight?: string;
+    height?: string;
+    hasBackdrop?: boolean;
+    zIndex?: number;
+    children: ReactNode;
+}
+export default function SlidingPanel({ isOpen, onClose, panelKey, side, width, minWidth, maxHeight, height, hasBackdrop, zIndex, children, }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/TagUpsert.d.ts

@@ -0,0 +1,8 @@
+interface Props {
+    currentTags: string[];
+    availableTags: string[];
+    onAddTag: (tag: string) => void;
+    isReadOnly?: boolean;
+}
+export default function TagUpsert({ currentTags, availableTags, onAddTag, isReadOnly, }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/TopMenuBar.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+import type { TopMenuBarSlots } from '../slots';
+interface Props extends TopMenuBarSlots {
+    children?: React.ReactNode;
+    hideMobileBar?: boolean;
+}
+export default function TopMenuBar({ children, hideMobileBar, rightSlot, mobileMenuSlot, userControlsSlot }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ViewBezierConnector.d.ts

@@ -0,0 +1,4 @@
+import { type EdgeProps } from 'reactflow';
+declare function ViewBezierConnector({ id, source, target, sourceX, sourceY, sourcePosition, targetX, targetY, targetPosition, style, label, labelStyle, labelBgStyle, labelShowBg: _labelShowBg, labelBgPadding, labelBgBorderRadius, markerStart, markerEnd, selected, }: EdgeProps): import("react/jsx-runtime").JSX.Element;
+declare const _default: import("react").MemoExoticComponent<typeof ViewBezierConnector>;
+export default _default;

package/dist/components/ViewDrawMenu.d.ts

@@ -0,0 +1,22 @@
+export declare function UndoSvg(): import("react/jsx-runtime").JSX.Element;
+export declare function RedoSvg(): import("react/jsx-runtime").JSX.Element;
+export declare function PencilSvg(): import("react/jsx-runtime").JSX.Element;
+export declare function EraserSvg(): import("react/jsx-runtime").JSX.Element;
+export declare function TextSvg(): import("react/jsx-runtime").JSX.Element;
+export declare function MoveSvg(): import("react/jsx-runtime").JSX.Element;
+export declare function CloseSvg(): import("react/jsx-runtime").JSX.Element;
+export interface ViewDrawMenuProps {
+    drawingMode: boolean;
+    drawingTool: 'pencil' | 'eraser' | 'text' | 'select';
+    setDrawingTool: (tool: 'pencil' | 'eraser' | 'text' | 'select') => void;
+    drawingColor: string;
+    setDrawingColor: (color: string) => void;
+    drawingWidth: number;
+    setDrawingWidth: (width: number) => void;
+    onUndo: () => void;
+    onRedo: () => void;
+    canUndo: boolean;
+    canRedo: boolean;
+    setDrawingMode: (mode: boolean) => void;
+}
+export default function ViewDrawMenu({ drawingMode, drawingTool, setDrawingTool, drawingColor, setDrawingColor, drawingWidth, setDrawingWidth, onUndo, onRedo, canUndo, canRedo, setDrawingMode, }: ViewDrawMenuProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/ViewEditorEdgeLabelLayout.d.ts

@@ -0,0 +1,16 @@
+export declare function measureEdgeLabel(text: string, font: string): number;
+interface UseEdgeLabelLayoutArgs {
+    id: string;
+    preferredX: number;
+    preferredY: number;
+    width: number;
+    height: number;
+    dx: number;
+    dy: number;
+    alongLineOnly?: boolean;
+}
+export declare function useEdgeLabelLayout({ id, preferredX, preferredY, width, height, dx, dy, alongLineOnly, }: UseEdgeLabelLayoutArgs): {
+    x: number;
+    y: number;
+};
+export {};

package/dist/components/ViewEditorOnboarding.d.ts

@@ -0,0 +1,5 @@
+interface Props {
+    hasElements: boolean;
+}
+export default function ViewEditorOnboarding({ hasElements }: Props): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/components/ViewExplorer/TagManager/ColorPicker.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface Props {
+    onSelect: (color: string) => void;
+    onClose: () => void;
+}
+export declare const ColorPicker: React.FC<Props>;
+export {};

package/dist/components/ViewExplorer/TagManager/GroupNamingPopover.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+interface Props {
+    isOpen: boolean;
+    onClose: () => void;
+    onConfirm: (name: string) => void | Promise<void>;
+    defaultName: string;
+    anchorEl?: HTMLElement | null;
+}
+export declare const GroupNamingPopover: React.FC<Props>;
+export {};

package/dist/components/ViewExplorer/TagManager/LayerItem.d.ts

@@ -0,0 +1,27 @@
+import React from 'react';
+import { ViewLayer } from '../../../types';
+interface Props {
+    layer: ViewLayer;
+    isActive: boolean;
+    isExpanded: boolean;
+    tagCount: number;
+    tagColors: Record<string, import('../../../types').Tag>;
+    onToggleActive: () => void;
+    onToggleExpanded: () => void;
+    onDelete: () => void;
+    onSetColor: (color: string) => void;
+    onSetTagColor?: (tag: string, color: string, description?: string) => void;
+    onAddTag: (tag: string) => void;
+    onRemoveTag: (tag: string) => void;
+    onHover: (active: boolean) => void;
+    selectedElementTags?: string[];
+    onToggleTagOnElement?: (tag: string) => void;
+    namingPopover?: {
+        isOpen: boolean;
+        defaultName: string;
+    };
+    onConfirmNaming?: (name: string) => void;
+    onCloseNaming?: () => void;
+}
+export declare const LayerItem: React.FC<Props>;
+export {};

package/dist/components/ViewExplorer/TagManager/TagItem.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+interface Props {
+    tag: string;
+    color: string;
+    isAssigned?: boolean;
+    tagCount?: number;
+    onToggle?: () => void;
+    onHover?: (active: boolean) => void;
+    onDropTag?: (draggedTag: string) => void;
+    onDropLayer?: (layerId: number) => void;
+    namingPopover?: {
+        isOpen: boolean;
+        defaultName: string;
+    };
+    onConfirmNaming?: (name: string) => void;
+    onCloseNaming?: () => void;
+    onSetColor?: (color: string) => void;
+    onSetDescription?: (description: string) => void;
+    onRemove?: () => void;
+    description?: string | null;
+    isVisible?: boolean;
+    onToggleVisibility?: () => void;
+}
+export declare const TagItem: React.FC<Props>;
+export {};

package/dist/components/ViewExplorer/TagManager/index.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import { ViewLayer, LibraryElement, PlacedElement } from '../../../types';
+interface Props {
+    availableTags: string[];
+    tagColors: Record<string, import('../../../types').Tag>;
+    layers: ViewLayer[];
+    viewElements: PlacedElement[];
+    selectedElement: LibraryElement | null;
+    hiddenLayerTags: string[];
+    setHiddenLayerTags: (tags: string[]) => void;
+    onToggleTagOnElement: (tag: string) => void;
+    onHoverLayer: (tags: string[] | null, color?: string | null) => void;
+    onCreateLayer: (name: string, tags: string[], color: string) => Promise<void>;
+    onUpdateLayer: (layer: ViewLayer) => Promise<void>;
+    onDeleteLayer: (id: number) => Promise<void>;
+    onCreateTag: (tag: string, color?: string, description?: string) => Promise<void>;
+    tagCounts: Record<string, number>;
+    layerCounts: Record<number, number>;
+}
+export declare const TagManager: React.FC<Props>;
+export {};

package/dist/components/ViewExplorer/ViewNavigator.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { NavItem } from './types';
+interface Props {
+    parents: NavItem[];
+    children: NavItem[];
+    activeFilter: 'out' | 'in' | null;
+    onFilterToggle: (type: 'out' | 'in', items: NavItem[]) => void;
+    onHoverZoom?: (elementId: number | null, type: 'in' | 'out' | null) => void;
+}
+export declare const ViewNavigator: React.FC<Props>;
+export {};

package/dist/components/ViewExplorer/ViewSearch.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+interface Props {
+    query: string;
+    setQuery: (q: string) => void;
+    activeFilter: 'out' | 'in' | null;
+}
+export declare const ViewSearch: React.FC<Props>;
+export {};

package/dist/components/ViewExplorer/ViewTree.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import { TreeNode } from './types';
+interface Props {
+    filtered: TreeNode[];
+    viewId: number | null;
+    focusedIdx: number;
+    itemRefs: React.MutableRefObject<(HTMLDivElement | null)[]>;
+    handleNavigate: (id: number) => void;
+    onHoverZoom?: (elementId: number | null, type: 'in' | 'out' | null) => void;
+    viewHoverMap: Map<number, {
+        elementId: number | undefined;
+        type: 'in' | 'out';
+    }>;
+    handleKeyDown: (e: React.KeyboardEvent) => void;
+    listRef: React.RefObject<HTMLDivElement>;
+}
+export declare const ViewTree: React.FC<Props>;
+export {};

package/dist/components/ViewExplorer/index.d.ts

@@ -0,0 +1,31 @@
+import React from 'react';
+import '../../styles/editor-panels.css';
+import type { ViewTreeNode, ViewConnector, PlacedElement, LibraryElement, ViewLayer, Tag } from '../../types';
+interface Props {
+    treeNodes: ViewTreeNode[];
+    linksMap: Record<number, ViewConnector[]>;
+    viewElements: PlacedElement[];
+    onNavigate: (id: number) => void;
+    onHoverZoom?: (elementId: number | null, type: 'in' | 'out' | null) => void;
+    isOpen: boolean;
+    onToggle: () => void;
+    isMobile?: boolean;
+    suppressed?: boolean;
+    activeTags: string[];
+    setActiveTags: (tags: string[]) => void;
+    hiddenLayerTags: string[];
+    setHiddenLayerTags: (tags: string[]) => void;
+    availableTags: string[];
+    tagColors: Record<string, Tag>;
+    selectedElement?: LibraryElement | null;
+    onUpdateTags?: (elementId: number, tags: string[]) => Promise<void>;
+    onCreateTag: (tag: string, color?: string) => Promise<void>;
+    layers: ViewLayer[];
+    onHoverLayer: (tags: string[] | null, color?: string | null) => void;
+    onCreateLayer: (name: string, tags: string[], color: string) => Promise<void>;
+    onUpdateLayer: (layer: ViewLayer) => Promise<void>;
+    onDeleteLayer: (id: number) => Promise<void>;
+}
+declare function ViewExplorer({ treeNodes, linksMap, viewElements, onNavigate, onHoverZoom, isOpen, onToggle, isMobile, suppressed, hiddenLayerTags, setHiddenLayerTags, availableTags, tagColors, selectedElement, onUpdateTags, onCreateTag, layers, onHoverLayer, onCreateLayer, onUpdateLayer, onDeleteLayer, }: Props): import("react/jsx-runtime").JSX.Element;
+declare const _default: React.MemoExoticComponent<typeof ViewExplorer>;
+export default _default;

package/dist/components/ViewExplorer/types.d.ts

@@ -0,0 +1,11 @@
+import type { ViewTreeNode } from '../../types';
+export interface TreeNode extends ViewTreeNode {
+    children: TreeNode[];
+    depth: number;
+}
+export interface NavItem {
+    id: number;
+    name: string;
+    subtitle?: string;
+    elementId?: number;
+}

package/dist/components/ViewExplorer/utils.d.ts

@@ -0,0 +1,6 @@
+import type { ViewTreeNode } from '../../types';
+import type { TreeNode } from './types';
+export declare const SWATCH_COLORS: string[];
+export declare function pickUnusedColor(usedColors: string[]): string;
+export declare function buildTree(nodes: ViewTreeNode[]): TreeNode[];
+export declare function flattenTree(roots: TreeNode[]): TreeNode[];

package/dist/components/ViewExplorer-vscode.d.ts

@@ -0,0 +1,6 @@
+/**
+ * VS Code variant of ViewExplorer.
+ * Diagram navigation is surfaced as a native VS Code tree view instead.
+ * This stub keeps the webview bundle lean.
+ */
+export default function ViewExplorer(): null;

package/dist/components/ViewFloatingMenu-vscode.d.ts

@@ -0,0 +1,27 @@
+import React from 'react';
+interface ViewFloatingMenuProps {
+    canEdit: boolean;
+    handleAddElementAtCenter: () => void;
+    drawingMode: boolean;
+    setDrawingMode: React.Dispatch<React.SetStateAction<boolean>>;
+    hasDrawingPaths: boolean;
+    drawingVisible: boolean;
+    setDrawingVisible: React.Dispatch<React.SetStateAction<boolean>>;
+    extrasOpen: boolean;
+    setExtrasOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    onImport: () => void;
+    onExport: () => void;
+    onShare: () => void;
+    isFreePlan: boolean;
+    canUpgrade?: boolean;
+    activeTags?: string[];
+    setActiveTags?: (tags: string[]) => void;
+    availableTags?: string[];
+}
+/**
+ * VS Code variant of ViewFloatingMenu.
+ * Import, Export, and Share are removed they are registered as VS Code commands instead.
+ * The extras toggle chevron is also removed since there are no extras to expand.
+ */
+export default function ViewFloatingMenu({ canEdit, handleAddElementAtCenter, drawingMode, setDrawingMode, hasDrawingPaths, drawingVisible, setDrawingVisible, activeTags, setActiveTags, availableTags, }: ViewFloatingMenuProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ViewFloatingMenu.d.ts

@@ -0,0 +1,39 @@
+import React from 'react';
+import type { ViewFloatingMenuSlots } from '../slots';
+import type { Tag, ViewLayer } from '../types';
+export interface ViewFloatingMenuProps extends ViewFloatingMenuSlots {
+    handleAddElementAtCenter: () => void;
+    drawingMode: boolean;
+    setDrawingMode: React.Dispatch<React.SetStateAction<boolean>>;
+    hasDrawingPaths: boolean;
+    drawingVisible: boolean;
+    setDrawingVisible: React.Dispatch<React.SetStateAction<boolean>>;
+    extrasOpen: boolean;
+    setExtrasOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    disableImportExport?: boolean;
+    onImport: () => void;
+    onExport: () => void;
+    onShare?: () => void;
+    focusMode: boolean;
+    onFocusModeChange: (enabled: boolean) => void;
+    allTags: string[];
+    layers: ViewLayer[];
+    tagColors: Record<string, Tag>;
+    hiddenTags: string[];
+    toggleTagVisibility: (tag: string) => void;
+    toggleLayerVisibility: (layer: ViewLayer) => void;
+    tagCounts: Record<string, number>;
+    layerElementCounts: Record<number, number>;
+    setHighlightedTags: (tags: string[] | null) => void;
+    setHighlightColor: (color: string | null) => void;
+    toolbarSlot?: React.ReactNode;
+}
+/**
+ * Name: Floating Menu
+ * Role: Shows add element, draw, export, import, and share buttons with a collapsible section.
+ * Location: Floating at the bottom center of the editor.
+ * Aliases: Bottom bar, Action bar.
+ */
+declare function ViewFloatingMenu({ handleAddElementAtCenter, drawingMode, setDrawingMode, hasDrawingPaths, drawingVisible, setDrawingVisible, extrasOpen, setExtrasOpen, disableImportExport, onImport, onExport, focusMode, onFocusModeChange, allTags, layers, tagColors, hiddenTags, toggleTagVisibility, toggleLayerVisibility, tagCounts, layerElementCounts, setHighlightedTags, setHighlightColor, shareSlot, toolbarSlot, }: ViewFloatingMenuProps): import("react/jsx-runtime").JSX.Element;
+declare const _default: React.MemoExoticComponent<typeof ViewFloatingMenu>;
+export default _default;

package/dist/components/ViewGridNode.d.ts

@@ -0,0 +1,29 @@
+export interface ViewGridNodeData {
+    id: number;
+    name: string;
+    level_label: string | null;
+    counts?: {
+        nodes: number;
+        edges: number;
+    };
+    focused: boolean;
+    canEdit: boolean;
+    isEditing: boolean;
+    editName: string;
+    onFocus: () => void;
+    onOpen: () => void;
+    onStartRename: () => void;
+    onDetails: () => void;
+    onDelete: () => void;
+    onShare: () => void;
+    onEditNameChange: (v: string) => void;
+    onEditCommit: () => void;
+    onEditCancel: () => void;
+    /** On touch/mobile: tap navigates directly instead of just focusing */
+    isMobile?: boolean;
+    /** Key that navigates to this card from the currently selected card */
+    wasdKey?: 'w' | 'a' | 's' | 'd';
+}
+export default function ViewGridNode({ data }: {
+    data: ViewGridNodeData;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/ViewHeaderButton.d.ts

@@ -0,0 +1,11 @@
+export interface ViewHeaderButtonProps {
+    name?: string;
+    onOpen: () => void;
+}
+/**
+ * Name: Diagram Button
+ * Role: Appears on the headerbar and it opens the diagram details panel.
+ * Location: Headerbar at the top.
+ * Aliases: Diagram Name Button, Header Title.
+ */
+export default function ViewHeaderButton({ name, onOpen }: ViewHeaderButtonProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/ViewPanel.d.ts

@@ -0,0 +1,18 @@
+import type { ViewTreeNode } from '../types';
+interface Props {
+    isOpen: boolean;
+    onClose: () => void;
+    view: ViewTreeNode | null;
+    canEdit?: boolean;
+    onSave: (updated: ViewTreeNode) => void;
+    hasBackdrop?: boolean;
+}
+/**
+ * Name: View Details Panel
+ * Role: Opens on the right and allows view field updates.
+ * Location: Right side of the screen on desktop. Overlays screen on mobile.
+ * Aliases: View Properties, View Settings.
+ */
+declare function ViewPanel({ isOpen, onClose, view, canEdit: canEditProp, onSave, hasBackdrop }: Props): import("react/jsx-runtime").JSX.Element;
+declare const _default: import("react").MemoExoticComponent<typeof ViewPanel>;
+export default _default;

package/dist/components/ViewsGridOnboarding.d.ts

@@ -0,0 +1,5 @@
+interface Props {
+    hasViews: boolean;
+}
+export default function ViewsGridOnboarding({ hasViews }: Props): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/components/ZUI/ZUICanvas.d.ts

@@ -0,0 +1,18 @@
+import type { ExploreData } from '../../types';
+import type { CrossBranchContextSettings } from '../../crossBranch/types';
+export interface ZUICanvasHandle {
+    fitView(): void;
+}
+interface Props {
+    data: ExploreData;
+    onReady?: () => void;
+    onZoom?: () => void;
+    onPan?: () => void;
+    highlightedTags?: string[];
+    highlightColor?: string;
+    hiddenTags?: string[];
+    crossBranchSettings: CrossBranchContextSettings;
+    hoverLocked?: boolean;
+}
+export declare const ZUICanvas: import("react").ForwardRefExoticComponent<Props & import("react").RefAttributes<ZUICanvasHandle>>;
+export {};

package/dist/components/ZUI/index.d.ts

@@ -0,0 +1,2 @@
+export { ZUICanvas } from './ZUICanvas';
+export type { ZUICanvasHandle } from './ZUICanvas';

package/dist/components/ZUI/layout.d.ts

@@ -0,0 +1,18 @@
+import type { ZUILayout } from './types';
+import type { ExploreData } from '../../types';
+export declare const NODE_W = 200;
+export declare const NODE_H = 100;
+/**
+ * Compute the full world-space layout for all diagrams in `data`.
+ * Root diagrams are placed side-by-side horizontally.
+ */
+export declare function computeLayout(data: ExploreData): ZUILayout;
+/**
+ * Compute the initial viewport that fits the entire layout on screen.
+ * Returns a ZUIViewState (x=panX, y=panY, zoom).
+ */
+export declare function fitViewport(layout: ZUILayout, canvasW: number, canvasH: number, padding?: number): {
+    x: number;
+    y: number;
+    zoom: number;
+};

package/dist/components/ZUI/proxy.d.ts

@@ -0,0 +1,25 @@
+import { type ZUIResolvedConnector } from '../../crossBranch/resolve';
+import type { WorkspaceGraphSnapshot } from '../../crossBranch/types';
+import type { LayoutNode, ZUIViewState, HoveredItem } from './types';
+import { type ScreenRect } from './renderer';
+import type { CrossBranchContextSettings } from '../../crossBranch/types';
+export interface VisibleNodeAnchor {
+    nodeId: string;
+    elementId: number;
+    label: string;
+    worldX: number;
+    worldY: number;
+    worldW: number;
+    worldH: number;
+    pathDepth: number;
+    renderAlpha: number;
+}
+export declare function collectVisibleNodeAnchors(groups: Array<{
+    nodes: LayoutNode[];
+}>, view: ZUIViewState, canvasW: number, hiddenTags?: string[]): {
+    visibleAnchors: Map<number, VisibleNodeAnchor>;
+    byNodeId: Map<string, VisibleNodeAnchor>;
+};
+export declare function buildVisibleProxyConnectors(snapshot: WorkspaceGraphSnapshot | null, visibleAnchors: Map<number, VisibleNodeAnchor>, settings: CrossBranchContextSettings): ZUIResolvedConnector[];
+export declare function drawVisibleProxyConnectors(ctx: CanvasRenderingContext2D, connectors: ZUIResolvedConnector[], visibleAnchorsByNodeId: Map<string, VisibleNodeAnchor>, zoom: number, labelBg: string, occupiedLabelRects: ScreenRect[]): void;
+export declare function findHoveredProxyConnector(worldX: number, worldY: number, connectors: ZUIResolvedConnector[], visibleAnchorsByNodeId: Map<string, VisibleNodeAnchor>, view: ZUIViewState): HoveredItem | null;

package/dist/components/ZUI/renderer.d.ts

@@ -0,0 +1,30 @@
+import type { DiagramGroupLayout, ZUIViewState } from './types';
+export declare function getExpandThresholds(canvasW: number): {
+    start: number;
+    end: number;
+};
+export interface ScreenRect {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}
+export declare function setOnImageLoadCallback(cb: (() => void) | null): void;
+export declare function setHighlightedTags(tags: Set<string>): void;
+export declare function setHighlightColor(color: string): void;
+export declare function setHiddenTags(tags: Set<string>): void;
+export declare function pickEdgeLabelPosition(matrix: DOMMatrix, midX: number, midY: number, textW: number, textH: number, dx: number, dy: number, occupiedLabelRects: ScreenRect[]): {
+    x: number;
+    y: number;
+};
+/** Is the rect (in world space) visible on screen? */
+export declare function isVisible(worldX: number, worldY: number, worldW: number, worldH: number, view: ZUIViewState, canvasW: number, canvasH: number): boolean;
+/** Is the rect (in world space) FULLY visible on screen? */
+export declare function isFullyVisible(worldX: number, worldY: number, worldW: number, worldH: number, view: ZUIViewState, canvasW: number, canvasH: number): boolean;
+/**
+ * Render a complete frame onto `ctx`.
+ * Call this from a `requestAnimationFrame` loop.
+ * The caller must set `ctx.setTransform(dpr,0,0,dpr,0,0)` before calling;
+ * `canvasW/canvasH` are CSS-pixel dimensions (the transform handles HiDPI).
+ */
+export declare function renderFrame(ctx: CanvasRenderingContext2D, groups: DiagramGroupLayout[], view: ZUIViewState, canvasW: number, canvasH: number): ScreenRect[];