@ultrst-armada/kloks 1.0.2 → 1.1.1

package/packages/state-graph/dist/spatial/index.js

@@ -1,8 +1,13 @@
 import {
   AttractionEngine,
+  GhostInferenceEngine,
+  GhostLayoutResolver,
+  GhostTracePathBuilder,
   calculateSocketCoordinates,
-  getBeamPoints
-} from "../chunk-YTWCH6P2.js";
+  getBeamPoints,
+  useMagneticTraces
+} from "../chunk-JXDJZSFW.js";
+import "../chunk-TZOL3RN7.js";
 import {
   AutoSolidify,
   SpatialEngine,
@@ -14,8 +19,12 @@ import "../chunk-3RG5ZIWI.js";
 export {
   AttractionEngine,
   AutoSolidify,
+  GhostInferenceEngine,
+  GhostLayoutResolver,
+  GhostTracePathBuilder,
   SpatialEngine,
   TraceEngine,
   calculateSocketCoordinates,
-  getBeamPoints
+  getBeamPoints,
+  useMagneticTraces
 };

package/packages/state-graph/dist/store/index.d.ts

@@ -1,6 +1,159 @@
-export { C as CommandApi, a as GhostStore, b as GhostStoreListener, d as GraphListener, e as GraphStore } from '../index-CiekWEH3.js';
-import '../BaseNode-1HCEqmap.js';
-import '../BaseConnection-CMRrL6Fe.js';
-import '../BaseGraph-Bl2f7Pqx.js';
-import '../TraceEngine-CJVpUb80.js';
-import '../CompatibilityMatrix-DX307_vS.js';
+import { N as NodePosition, a as NodeSize, b as BaseNode, e as BaseNodeProps, h as HandleOffset } from '../BaseNode-DTcd3K1B.js';
+import { V as ViewLink, S as SolidConnection } from '../BaseConnection-CMRrL6Fe.js';
+import { a as BaseViewWindow, L as Landmark, e as GraphView, G as GraphSettings, f as Group } from '../BaseGraph-BvkSYOTw.js';
+import { T as Trace, c as GhostNodeRecord, e as GhostTraceRecord } from '../types-VDoc4FIc.js';
+import '../CompatibilityMatrix-Dj-tCWUA.js';
+
+interface CreateViewWindowParams {
+    id?: string;
+    viewType: string;
+    sourceNodeId: string;
+    sourceViewHandleId: string;
+    position: NodePosition;
+    size?: NodeSize;
+}
+declare class ViewWindowManager {
+    private windows;
+    private links;
+    createWindow(params: CreateViewWindowParams): {
+        window: BaseViewWindow;
+        link: ViewLink;
+    };
+    selectWindow(id: string): void;
+    pinLive(id: string, pinned: boolean): void;
+    removeWindow(id: string): boolean;
+    getProcessingWindows(): BaseViewWindow[];
+    getWindow(id: string): BaseViewWindow | undefined;
+    getLink(windowId: string): ViewLink | undefined;
+    listWindows(): BaseViewWindow[];
+    listLinks(): ViewLink[];
+}
+
+declare class LandmarkManager {
+    private landmarks;
+    constructor(initialLandmarks?: Landmark[]);
+    createLandmark(number: number, name: string, cameraPosition: {
+        x: number;
+        y: number;
+    }, zoom: number): Landmark;
+    getByNumber(number: number): Landmark | undefined;
+    getById(id: string): Landmark | undefined;
+    updateLandmark(id: string, updates: Partial<Omit<Landmark, 'id'>>): Landmark | undefined;
+    deleteLandmark(id: string): boolean;
+    list(): Landmark[];
+    clear(): void;
+}
+
+interface CaptureGraphSnapshotParams {
+    id?: string;
+    name: string;
+    nodes: BaseNode[];
+    viewWindows: BaseViewWindow[];
+    camera: {
+        x: number;
+        y: number;
+    };
+    zoom: number;
+    selectedNodeIds: string[];
+    settingsOverrides?: Partial<GraphSettings>;
+}
+declare class ViewEngine {
+    private views;
+    constructor(initialViews?: GraphView[]);
+    captureView(params: CaptureGraphSnapshotParams): GraphView;
+    getView(id: string): GraphView | undefined;
+    listViews(): GraphView[];
+    deleteView(id: string): boolean;
+}
+
+type GraphListener = () => void;
+declare class GraphStore {
+    nodes: BaseNode[];
+    connections: SolidConnection[];
+    traces: Trace[];
+    groups: Group[];
+    settings: GraphSettings;
+    selectedNodeIds: Set<string>;
+    readonly viewWindows: ViewWindowManager;
+    readonly landmarks: LandmarkManager;
+    readonly views: ViewEngine;
+    private listeners;
+    subscribe(listener: GraphListener): () => void;
+    notify(): void;
+    refreshTraces(): void;
+    solidifyTrace(traceId: string): SolidConnection | undefined;
+    lockAllConnections(): void;
+}
+
+declare class CommandApi {
+    private store;
+    constructor(store: GraphStore);
+    get nodes(): {
+        create: (props: BaseNodeProps) => BaseNode;
+        delete: (nodeId: string) => void;
+        move: (nodeId: string, x: number, y: number) => void;
+        lockPosition: (nodeId: string) => void;
+        unlockPosition: (nodeId: string) => void;
+    };
+    get handles(): {
+        move: (nodeId: string, handleId: string, offset: HandleOffset) => void;
+        resetOffset: (nodeId: string, handleId: string) => void;
+    };
+    get traces(): {
+        refresh: () => void;
+        enable: () => void;
+        disable: () => void;
+        solidify: (traceId: string) => SolidConnection;
+    };
+    get connections(): {
+        create: (sourceNodeId: string, sourceHandleId: string, targetNodeId: string, targetHandleId: string, wireType?: string) => SolidConnection;
+        delete: (connectionId: string) => void;
+        lock: (connectionId: string) => void;
+        unlock: (connectionId: string) => void;
+        lockAll: () => void;
+    };
+    get groups(): {
+        create: (group: Group) => void;
+        delete: (groupId: string) => void;
+    };
+    get landmarks(): {
+        create: (num: number, name: string, camera: {
+            x: number;
+            y: number;
+        }, zoom: number) => Landmark;
+        delete: (id: string) => boolean;
+        list: () => Landmark[];
+    };
+    get viewWindows(): {
+        create: (params: Parameters<typeof this$1.store.viewWindows.createWindow>[0]) => {
+            window: BaseViewWindow;
+            link: ViewLink;
+        };
+        close: (id: string) => boolean;
+        select: (id: string) => void;
+        pinLive: (id: string, pinned: boolean) => void;
+    };
+}
+
+type GhostStoreListener = () => void;
+declare class GhostStore {
+    private static instance;
+    isActive: boolean;
+    ghostNodes: GhostNodeRecord[];
+    ghostTraces: GhostTraceRecord[];
+    scenarioIndex: number;
+    hoveredGhostId: string | null;
+    sourceNodeIds: string[];
+    private listeners;
+    static getInstance(): GhostStore;
+    subscribe(listener: GhostStoreListener): () => void;
+    notify(): void;
+    setPredictions(nodes: GhostNodeRecord[], traces: GhostTraceRecord[], sourceNodeIds: string[]): void;
+    cycleScenario(maxScenarios?: number): void;
+    setHoveredGhostId(id: string | null): void;
+    getActiveGhostNodes(): GhostNodeRecord[];
+    getActiveGhostTraces(): GhostTraceRecord[];
+    clear(): void;
+}
+
+export { CommandApi, GhostStore, type GhostStoreListener, type GraphListener, GraphStore };

package/packages/state-graph/dist/types-VDoc4FIc.d.ts

@@ -0,0 +1,150 @@
+import { b as BaseNode, c as HandleDirection, B as BaseHandle } from './BaseNode-DTcd3K1B.js';
+import { C as CompatibilityResolution } from './CompatibilityMatrix-Dj-tCWUA.js';
+
+interface Trace {
+    id: string;
+    sourceNodeId: string;
+    sourceHandleId: string;
+    targetNodeId: string;
+    targetHandleId: string;
+    wireType: string;
+    compatibility: CompatibilityResolution;
+    spatialScore: number;
+}
+declare class TraceEngine {
+    static computeTraces(nodes: BaseNode[], cutoffDistance: number): Trace[];
+}
+
+type SocketType = 'input' | 'output';
+interface Socket {
+    id: string;
+    label: string;
+    type: SocketType;
+    dataType?: string;
+    direction?: HandleDirection;
+    offset?: {
+        x: number;
+        y: number;
+    };
+    basePosition?: {
+        x: number;
+        y: number;
+    };
+    connectionMode?: 'SINGLE' | 'MULTI';
+}
+interface GraphNode {
+    id: string;
+    type: string;
+    label: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    size?: {
+        width: number;
+        height: number;
+    };
+    data?: Record<string, unknown>;
+    inputs?: Socket[];
+    outputs?: Socket[];
+    width?: number;
+    height?: number;
+    positionLocked?: boolean;
+    minimized?: boolean;
+    handles?: BaseHandle[];
+}
+interface GraphEdge {
+    id: string;
+    source: string;
+    sourceSocket: string;
+    target: string;
+    targetSocket: string;
+    label?: string;
+    color?: string;
+    wireType?: string;
+    locked?: boolean;
+    deletable?: boolean;
+}
+interface ViewportState {
+    panX: number;
+    panY: number;
+    zoom: number;
+}
+interface NodeGraphConfig {
+    minZoom?: number;
+    maxZoom?: number;
+    gridSize?: number;
+    snapToGrid?: boolean;
+    wireStyle?: 'bezier' | 'straight' | 'step';
+    tracingEnabled?: boolean;
+    magneticTracesEnabled?: boolean;
+    autoSolidify?: boolean;
+    traceCutoffDistance?: number;
+    ghostRoutingEnabled?: boolean;
+    ghostScenarioCount?: number;
+    ghostDecayMs?: number;
+}
+interface NodeGraphPlugin {
+    registerNodeDefinition?: (def: unknown) => void;
+    registerHandleType?: (type: string) => void;
+    registerWireType?: (wire: unknown) => void;
+    registerCompatibilityRule?: (rule: unknown) => void;
+    registerViewType?: (view: unknown) => void;
+    registerTheme?: (theme: unknown) => void;
+    registerContextMenuAction?: (action: unknown) => void;
+    registerSpawnMenuItem?: (item: unknown) => void;
+}
+
+interface GhostSocketMapping {
+    sourceSocketId: string;
+    targetSocketId: string;
+    wireType: string;
+}
+interface GhostCandidate {
+    id: string;
+    nodeType: string;
+    label: string;
+    scenarioIndex: number;
+    score: number;
+    sourceNodeId: string;
+    socketMappings: GhostSocketMapping[];
+    relativeOffset: {
+        x: number;
+        y: number;
+    };
+}
+interface GhostNodeRecord {
+    id: string;
+    nodeType: string;
+    label: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    size: {
+        width: number;
+        height: number;
+    };
+    scenarioIndex: number;
+    sourceNodeId: string;
+    socketMappings: GhostSocketMapping[];
+    inputs?: Socket[];
+    outputs?: Socket[];
+}
+interface GhostTraceRecord {
+    id: string;
+    sourceNodeId: string;
+    sourceSocketId: string;
+    targetGhostNodeId: string;
+    targetSocketId: string;
+    wireType: string;
+    pathD: string;
+    scenarioIndex: number;
+}
+interface GhostInferenceOptions {
+    scenarioCount?: number;
+    maxSuggestionsPerNode?: number;
+    customScorer?: (sourceType: string, candidateType: string) => number;
+}
+
+export { type GraphNode as G, type NodeGraphConfig as N, type Socket as S, type Trace as T, type ViewportState as V, type GhostCandidate as a, type GhostInferenceOptions as b, type GhostNodeRecord as c, type GhostSocketMapping as d, type GhostTraceRecord as e, type GraphEdge as f, type NodeGraphPlugin as g, type SocketType as h, TraceEngine as i };

package/packages/state-graph/dist/TraceEngine-CJVpUb80.d.ts

@@ -1,18 +0,0 @@
-import { B as BaseNode } from './BaseNode-1HCEqmap.js';
-import { C as CompatibilityResolution } from './CompatibilityMatrix-DX307_vS.js';
-
-interface Trace {
-    id: string;
-    sourceNodeId: string;
-    sourceHandleId: string;
-    targetNodeId: string;
-    targetHandleId: string;
-    wireType: string;
-    compatibility: CompatibilityResolution;
-    spatialScore: number;
-}
-declare class TraceEngine {
-    static computeTraces(nodes: BaseNode[], cutoffDistance: number): Trace[];
-}
-
-export { type Trace as T, TraceEngine as a };

package/packages/state-graph/dist/chunk-YTWCH6P2.js

@@ -1,109 +0,0 @@
-// src/spatial/AttractionEngine.ts
-var AttractionEngine = class {
-  static computeSimilarity(nodeA, nodeB) {
-    if (nodeA.id === nodeB.id) return 1;
-    let score = 0;
-    let factors = 0;
-    factors += 1;
-    if (nodeA.type === nodeB.type) {
-      score += 1;
-    }
-    factors += 1;
-    const inTypesA = new Set(nodeA.handles.filter((h) => h.direction === "INPUT").map((h) => h.dataType));
-    const inTypesB = new Set(nodeB.handles.filter((h) => h.direction === "INPUT").map((h) => h.dataType));
-    const sharedIn = [...inTypesA].filter((t) => inTypesB.has(t)).length;
-    const totalIn = Math.max(1, (/* @__PURE__ */ new Set([...inTypesA, ...inTypesB])).size);
-    score += sharedIn / totalIn;
-    factors += 1;
-    const outTypesA = new Set(nodeA.handles.filter((h) => h.direction === "OUTPUT").map((h) => h.dataType));
-    const outTypesB = new Set(nodeB.handles.filter((h) => h.direction === "OUTPUT").map((h) => h.dataType));
-    const sharedOut = [...outTypesA].filter((t) => outTypesB.has(t)).length;
-    const totalOut = Math.max(1, (/* @__PURE__ */ new Set([...outTypesA, ...outTypesB])).size);
-    score += sharedOut / totalOut;
-    return factors > 0 ? score / factors : 0;
-  }
-  static calculateStep(nodes, strength = 1, speed = 1) {
-    const updatedPositions = /* @__PURE__ */ new Map();
-    for (let i = 0; i < nodes.length; i++) {
-      const nodeA = nodes[i];
-      if (nodeA.positionLocked) {
-        updatedPositions.set(nodeA.id, { ...nodeA.position });
-        continue;
-      }
-      let forceX = 0;
-      let forceY = 0;
-      for (let j = 0; j < nodes.length; j++) {
-        if (i === j) continue;
-        const nodeB = nodes[j];
-        const similarity = this.computeSimilarity(nodeA, nodeB);
-        if (similarity <= 0.1) continue;
-        const dx = nodeB.position.x - nodeA.position.x;
-        const dy = nodeB.position.y - nodeA.position.y;
-        const dist = Math.max(20, Math.sqrt(dx * dx + dy * dy));
-        const f = similarity * strength * speed;
-        forceX += dx / dist * f;
-        forceY += dy / dist * f;
-      }
-      updatedPositions.set(nodeA.id, {
-        x: nodeA.position.x + forceX,
-        y: nodeA.position.y + forceY
-      });
-    }
-    return updatedPositions;
-  }
-};
-
-// src/spatial/socketCoordinates.ts
-function calculateSocketCoordinates(baseY, options) {
-  const clearance = Math.max(12, options.clearance ?? 14);
-  const nudge = options.nudge ?? { x: 0, y: 0 };
-  const halfWidth = options.cardWidth / 2;
-  const halfHeight = (options.cardHeight ?? 80) / 2;
-  const baseX = options.isOutput ? halfWidth + clearance : -halfWidth - clearance;
-  let effectiveX = baseX + nudge.x;
-  let effectiveY = baseY + nudge.y;
-  const minMargin = 4;
-  const bodyLeft = -halfWidth;
-  const bodyRight = halfWidth;
-  const bodyTop = -halfHeight;
-  const bodyBottom = halfHeight;
-  if (effectiveX > bodyLeft - minMargin && effectiveX < bodyRight + minMargin && effectiveY > bodyTop - minMargin && effectiveY < bodyBottom + minMargin) {
-    if (options.isOutput) {
-      effectiveX = bodyRight + Math.max(minMargin, clearance / 2);
-    } else {
-      effectiveX = bodyLeft - Math.max(minMargin, clearance / 2);
-    }
-  }
-  return {
-    baseX,
-    effectiveX,
-    effectiveY,
-    nudge: {
-      x: effectiveX - baseX,
-      y: effectiveY - baseY
-    }
-  };
-}
-var getBeamPoints = (nudge, baseW = 5, headW = 1.2) => {
-  const vx = -nudge.x;
-  const vy = -nudge.y;
-  const d = Math.sqrt(vx * vx + vy * vy);
-  if (d < 1) return "";
-  const px = -vy / d;
-  const py = vx / d;
-  const hL_x = -px * headW;
-  const hL_y = -py * headW;
-  const hR_x = px * headW;
-  const hR_y = py * headW;
-  const bR_x = vx + px * baseW;
-  const bR_y = vy + py * baseW;
-  const bL_x = vx - px * baseW;
-  const bL_y = vy - py * baseW;
-  return `${hL_x},${hL_y} ${hR_x},${hR_y} ${bR_x},${bR_y} ${bL_x},${bL_y}`;
-};
-
-export {
-  AttractionEngine,
-  calculateSocketCoordinates,
-  getBeamPoints
-};