@ultrst-armada/kloks 1.1.0 → 1.2.0

package/packages/backend/dist/krnl-services.js

@@ -13,13 +13,13 @@ import {
   StorageServiceFacade,
   WorkspaceServiceDefinition,
   WorkspaceServiceFacade
-} from "./chunk-CU7RZBMF.js";
-import "./chunk-IPP4VURQ.js";
+} from "./chunk-OYQKQAEF.js";
 import "./chunk-J2J24JVC.js";
 import "./chunk-FZKBTF34.js";
 import "./chunk-25Y7AVTP.js";
 import "./chunk-QGHDJGYS.js";
 import "./chunk-3EPY34R6.js";
+import "./chunk-IPP4VURQ.js";
 export {
   AuthServiceDefinition,
   AuthServiceFacade,

package/packages/backend/dist/storage/index.d.ts

@@ -1,6 +1,6 @@
 import { B as BaseStorageAdapter, S as StorageConfig, F as FileInfo, D as DeleteFolderResult, R as RenameFolderResult, C as ConnectionTestResult } from '../BaseStorageAdapter-tosOoSUg.js';
 export { a as StorageMode, b as StorageProviderType, U as UploadResult } from '../BaseStorageAdapter-tosOoSUg.js';
-import '@ultrst-armada/kloks/functions';
+import '@kloks/functions';
 
 declare class LocalFSAdapter extends BaseStorageAdapter {
     private basePath;

package/packages/backend/dist/workspace/index.d.ts

@@ -1,5 +1,5 @@
 import { B as BaseStorageAdapter, F as FileInfo } from '../BaseStorageAdapter-tosOoSUg.js';
-import { SkipoBase } from '@ultrst-armada/kloks/functions';
+import { SkipoBase } from '@kloks/functions';
 
 interface WorkspaceDescriptor {
     id: string;

package/packages/orchestrations/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { CounterState, TelemetryEvents } from '@ultrst-armada/kloks/services';
-import { ExecutableBackendFacade, WorkerExecutionBoundary } from '@ultrst-armada/kloks/backend/execution';
+import { CounterState, TelemetryEvents } from '@kloks/services';
+import { ExecutableBackendFacade, WorkerExecutionBoundary } from '@kloks/backend/execution';
 
 /**
  * @file backendExecutionFacade.ts
@@ -14,7 +14,7 @@ declare const workerExecutionBoundary: WorkerExecutionBoundary;
 
 /**
  * @file index.ts
- * @description @ultrst-armada/kloks/orchestrations — Canonical Orchestrators A & B built on KrnlTS & @ultrst-armada/kloks/services.
+ * @description @kloks/orchestrations — Canonical Orchestrators A & B built on KrnlTS & @kloks/services.
  * Orchestrator A: Service A (Pure) -> Service B (Stateful)
  * Orchestrator B: Service B (Stateful) -> Service C (Event-Emitting)
  */

package/packages/orchestrations/dist/index.js

@@ -3,7 +3,7 @@ import {
   ServiceAFacade,
   ServiceBFacade,
   ServiceCFacade
-} from "@ultrst-armada/kloks/services";
+} from "@kloks/services";
 
 // src/worker-facade/backendExecutionFacade.ts
 import {
@@ -11,8 +11,8 @@ import {
   WorkerExecutionBoundary,
   ServiceDispatcher,
   createOperationComponent
-} from "@ultrst-armada/kloks/backend/execution";
-import { SKIPO_EXECUTION } from "@ultrst-armada/kloks/state-graph";
+} from "@kloks/backend/execution";
+import { SKIPO_EXECUTION } from "@kloks/state-graph";
 var WorkspaceBackendFacade = class extends ExecutableBackendFacade {
 };
 var backendFacade = new WorkspaceBackendFacade("WorkspaceBackendFacade");

package/packages/services/dist/index.d.ts

@@ -1,7 +1,7 @@
 import * as _ultrst_armada_krnl from '@ultrst-armada/krnl';
 import { ServiceDefinition, IService, EndpointDescriptor, ProtocolAdapter } from '@ultrst-armada/krnl';
-import { AdminDatabaseClusterConfig, DatabaseConnectionEntry, UserStorageConnection, AuthState, UserAccount, UserRole, UserWorkspaceRecord } from '@ultrst-armada/kloks/state-graph';
-export { AuthState, UserAccount, UserRole, UserSession, UserStorageConnection, UserWorkspaceRecord } from '@ultrst-armada/kloks/state-graph';
+import { AdminDatabaseClusterConfig, DatabaseConnectionEntry, UserStorageConnection, AuthState, UserAccount, UserRole, UserWorkspaceRecord } from '@kloks/state-graph';
+export { AuthState, UserAccount, UserRole, UserSession, UserStorageConnection, UserWorkspaceRecord } from '@kloks/state-graph';
 
 interface SystemEnvironmentStatus {
     databaseUrlConfigured: boolean;
@@ -282,7 +282,7 @@ declare const SystemDbClientServiceFacade: {
 
 /**
  * @file index.ts
- * @description @ultrst-armada/kloks/services — Canonical KrnlTS Services A, B, C, D.
+ * @description @kloks/services — Canonical KrnlTS Services A, B, C, D.
  * Exports ServiceFacade, ServiceDefinition, and related types for each service.
  * Built strictly on KrnlTS with zero dependency on Skipo or Floks.
  */

package/packages/state-graph/dist/{BaseGraph-Bl2f7Pqx.d.ts → BaseGraph-BvkSYOTw.d.ts}

@@ -1,4 +1,4 @@
-import { N as NodePosition, b as NodeSize, B as BaseNode } from './BaseNode-1HCEqmap.js';
+import { N as NodePosition, a as NodeSize, b as BaseNode } from './BaseNode-DTcd3K1B.js';
 import { B as BaseConnection } from './BaseConnection-CMRrL6Fe.js';
 
 type DynamicState = 'INACTIVE' | 'ACTIVE' | 'PINNED_LIVE';

package/packages/state-graph/dist/{BaseNode-1HCEqmap.d.ts → BaseNode-DTcd3K1B.d.ts}

@@ -120,4 +120,4 @@ declare class CustomNode extends BaseNode {
     customDefinition?: NodeDefinition;
 }
 
-export { BaseNode as B, type ConnectionMode as C, DataHandle as D, type HandleCategory as H, type NodePosition as N, ViewHandle as V, BaseHandle as a, type NodeSize as b, type BaseHandleProps as c, type BaseNodeProps as d, CustomNode as e, type HandleDefinition as f, type HandleDirection as g, type HandleOffset as h, type HandlePosition as i, type NodeDefinition as j };
+export { BaseHandle as B, type ConnectionMode as C, DataHandle as D, type HandleCategory as H, type NodePosition as N, ViewHandle as V, type NodeSize as a, BaseNode as b, type HandleDirection as c, type BaseHandleProps as d, type BaseNodeProps as e, CustomNode as f, type HandleDefinition as g, type HandleOffset as h, type HandlePosition as i, type NodeDefinition as j };

package/packages/state-graph/dist/{CompatibilityMatrix-DX307_vS.d.ts → CompatibilityMatrix-Dj-tCWUA.d.ts}

@@ -1,4 +1,4 @@
-import { a as BaseHandle, H as HandleCategory } from './BaseNode-1HCEqmap.js';
+import { B as BaseHandle, H as HandleCategory } from './BaseNode-DTcd3K1B.js';
 
 interface CompatibilityRule {
     sourceCategory: HandleCategory;

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

@@ -0,0 +1,459 @@
+import {
+  ConnectionRuleStore,
+  WireTypeRegistry
+} from "./chunk-TZOL3RN7.js";
+
+// 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}`;
+};
+
+// src/spatial/useMagneticTraces.ts
+import { useMemo, useCallback } from "react";
+function getSocketCanvasPos(node, socket, isOut, idx, total) {
+  const h = node.height ?? 130;
+  const w = node.width ?? 130;
+  const topOffset = total === 1 ? h * 0.5 : h * 0.25 + idx * 24;
+  const nudge = socket.offset ?? { x: 0, y: 0 };
+  const baseX = isOut ? node.position.x + w : node.position.x;
+  return {
+    x: baseX + nudge.x,
+    y: node.position.y + topOffset + nudge.y
+  };
+}
+function useMagneticTraces({
+  nodes,
+  edges,
+  config,
+  onEdgesChange
+}) {
+  const isEnabled = config?.magneticTracesEnabled !== false && config?.tracingEnabled !== false;
+  const cutoff = config?.traceCutoffDistance ?? 220;
+  const traces = useMemo(() => {
+    if (!isEnabled || nodes.length < 2) return [];
+    const existingEdgeKeys = new Set(
+      edges.map((e) => `${e.source}:${e.sourceSocket}->${e.target}:${e.targetSocket}`)
+    );
+    const candidates = [];
+    for (let i = 0; i < nodes.length; i++) {
+      const srcNode = nodes[i];
+      const outputs = srcNode.outputs ?? [];
+      if (outputs.length === 0) continue;
+      for (let j = 0; j < nodes.length; j++) {
+        if (i === j) continue;
+        const tgtNode = nodes[j];
+        const inputs = tgtNode.inputs ?? [];
+        if (inputs.length === 0) continue;
+        outputs.forEach((outSock, outIdx) => {
+          const outPos = getSocketCanvasPos(srcNode, outSock, true, outIdx, outputs.length);
+          inputs.forEach((inSock, inIdx) => {
+            const edgeKey = `${srcNode.id}:${outSock.id}->${tgtNode.id}:${inSock.id}`;
+            if (existingEdgeKeys.has(edgeKey)) return;
+            const inPos = getSocketCanvasPos(tgtNode, inSock, false, inIdx, inputs.length);
+            const dist = Math.hypot(inPos.x - outPos.x, inPos.y - outPos.y);
+            if (dist <= cutoff) {
+              const canConnect = ConnectionRuleStore.canConnect(
+                { dataType: outSock.dataType || "ANY", direction: "OUTPUT", handleCategory: "DATA" },
+                { dataType: inSock.dataType || "ANY", direction: "INPUT", handleCategory: "DATA" }
+              );
+              if (canConnect) {
+                const resolution = ConnectionRuleStore.resolve(
+                  { dataType: outSock.dataType || "ANY", direction: "OUTPUT", handleCategory: "DATA" },
+                  { dataType: inSock.dataType || "ANY", direction: "INPUT", handleCategory: "DATA" }
+                );
+                const wireType = resolution.wireType || "DEFAULT";
+                const wireDef = WireTypeRegistry.get(wireType);
+                const color = wireDef?.color || "#61afef";
+                const delta = Math.max(Math.abs(inPos.x - outPos.x) * 0.5, 40);
+                const pathD = `M ${outPos.x},${outPos.y} C ${outPos.x + delta},${outPos.y} ${inPos.x - delta},${inPos.y} ${inPos.x},${inPos.y}`;
+                candidates.push({
+                  id: `mag-${srcNode.id}-${outSock.id}->${tgtNode.id}-${inSock.id}`,
+                  sourceNodeId: srcNode.id,
+                  sourceSocketId: outSock.id,
+                  targetNodeId: tgtNode.id,
+                  targetSocketId: inSock.id,
+                  wireType,
+                  color,
+                  pathD,
+                  midpoint: { x: (outPos.x + inPos.x) / 2, y: (outPos.y + inPos.y) / 2 },
+                  distance: dist
+                });
+              }
+            }
+          });
+        });
+      }
+    }
+    candidates.sort((a, b) => a.distance - b.distance);
+    const claimedOutputs = /* @__PURE__ */ new Set();
+    const claimedInputs = /* @__PURE__ */ new Set();
+    const filtered = [];
+    for (const c of candidates) {
+      const outKey = `${c.sourceNodeId}:${c.sourceSocketId}`;
+      const inKey = `${c.targetNodeId}:${c.targetSocketId}`;
+      if (!claimedOutputs.has(outKey) && !claimedInputs.has(inKey)) {
+        claimedOutputs.add(outKey);
+        claimedInputs.add(inKey);
+        filtered.push(c);
+      }
+    }
+    return filtered;
+  }, [nodes, edges, isEnabled, cutoff]);
+  const solidifyTrace = useCallback((traceId) => {
+    const trace = traces.find((t) => t.id === traceId);
+    if (!trace || !onEdgesChange) return;
+    const newEdge = {
+      id: `edge-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+      source: trace.sourceNodeId,
+      sourceSocket: trace.sourceSocketId,
+      target: trace.targetNodeId,
+      targetSocket: trace.targetSocketId,
+      wireType: trace.wireType,
+      color: trace.color,
+      locked: true
+    };
+    onEdgesChange([...edges, newEdge]);
+  }, [traces, edges, onEdgesChange]);
+  const solidifyAll = useCallback(() => {
+    if (traces.length === 0 || !onEdgesChange) return;
+    const newEdges = traces.map((t, idx) => ({
+      id: `edge-${Date.now()}-${idx}`,
+      source: t.sourceNodeId,
+      sourceSocket: t.sourceSocketId,
+      target: t.targetNodeId,
+      targetSocket: t.targetSocketId,
+      wireType: t.wireType,
+      color: t.color,
+      locked: true
+    }));
+    onEdgesChange([...edges, ...newEdges]);
+  }, [traces, edges, onEdgesChange]);
+  return {
+    traces,
+    isEnabled,
+    solidifyTrace,
+    solidifyAll
+  };
+}
+
+// src/spatial/prediction/GhostInferenceEngine.ts
+var GhostInferenceEngine = class {
+  static inferNextNodes(selectedNodes, allNodeDefs, options = {}) {
+    if (selectedNodes.length === 0 || allNodeDefs.length === 0) {
+      return [];
+    }
+    const scenarioCount = Math.max(1, options.scenarioCount ?? 3);
+    const maxSuggestions = options.maxSuggestionsPerNode ?? 2;
+    const candidates = [];
+    for (const sourceNode of selectedNodes) {
+      const outputSockets = sourceNode.outputs ?? [];
+      if (outputSockets.length === 0) continue;
+      const scoredDefs = [];
+      for (const def of allNodeDefs) {
+        if (def.type === sourceNode.type) continue;
+        const mappings = this.resolveSocketMappings(outputSockets, def);
+        if (mappings.length === 0) continue;
+        let score = mappings.length * 10;
+        if (options.customScorer) {
+          score += options.customScorer(sourceNode.type, def.type);
+        } else {
+          score += this.computeAffinityScore(sourceNode.type, def.type);
+        }
+        scoredDefs.push({ def, mappings, score });
+      }
+      scoredDefs.sort((a, b) => b.score - a.score);
+      for (let sIdx = 0; sIdx < scenarioCount; sIdx++) {
+        const slice = scoredDefs.slice(sIdx * maxSuggestions, (sIdx + 1) * maxSuggestions);
+        for (let i = 0; i < slice.length; i++) {
+          const match = slice[i];
+          const yOffset = (i - (slice.length - 1) / 2) * 140;
+          candidates.push({
+            id: `ghost-${sourceNode.id}-${match.def.type}-s${sIdx}-${i}`,
+            nodeType: match.def.type,
+            label: match.def.label || match.def.type,
+            scenarioIndex: sIdx,
+            score: match.score,
+            sourceNodeId: sourceNode.id,
+            socketMappings: match.mappings,
+            relativeOffset: { x: 260, y: yOffset }
+          });
+        }
+      }
+    }
+    return candidates;
+  }
+  static resolveSocketMappings(sourceOutputs, targetDef) {
+    const mappings = [];
+    const targetInputs = targetDef.inputs ?? [];
+    for (const outSocket of sourceOutputs) {
+      const matchingInput = targetInputs.find((inp) => {
+        return ConnectionRuleStore.canConnect(
+          { dataType: outSocket.dataType || "ANY", direction: "OUTPUT", handleCategory: "DATA" },
+          { dataType: inp.dataType || "ANY", direction: "INPUT", handleCategory: "DATA" }
+        );
+      });
+      if (matchingInput) {
+        const resolution = ConnectionRuleStore.resolve(
+          { dataType: outSocket.dataType || "ANY", direction: "OUTPUT", handleCategory: "DATA" },
+          { dataType: matchingInput.dataType || "ANY", direction: "INPUT", handleCategory: "DATA" }
+        );
+        mappings.push({
+          sourceSocketId: outSocket.id,
+          targetSocketId: matchingInput.id,
+          wireType: resolution.wireType || "DEFAULT"
+        });
+      }
+    }
+    return mappings;
+  }
+  static computeAffinityScore(sourceType, targetType) {
+    const s = sourceType.toLowerCase();
+    const t = targetType.toLowerCase();
+    if ((s.includes("source") || s.includes("input")) && (t.includes("process") || t.includes("filter"))) return 15;
+    if ((s.includes("process") || s.includes("filter")) && (t.includes("sink") || t.includes("output"))) return 15;
+    if (s.includes("audio") && t.includes("audio")) return 12;
+    if (s.includes("data") && t.includes("data")) return 10;
+    return 5;
+  }
+};
+
+// src/spatial/prediction/GhostLayoutResolver.ts
+var GhostLayoutResolver = class {
+  static resolveLayout(candidates, existingNodes, allNodeDefs) {
+    const nodeMap = new Map(existingNodes.map((n) => [n.id, n]));
+    const defMap = new Map(allNodeDefs.map((d) => [d.type, d]));
+    const occupiedRects = existingNodes.map((n) => ({
+      x: n.position.x,
+      y: n.position.y,
+      width: n.width ?? 180,
+      height: n.height ?? 120
+    }));
+    const resolved = [];
+    for (const cand of candidates) {
+      const source = nodeMap.get(cand.sourceNodeId);
+      const def = defMap.get(cand.nodeType);
+      const width = 180;
+      const height = 120;
+      const baseX = (source ? source.position.x + (source.width ?? 180) : 0) + 80;
+      const baseY = (source ? source.position.y : 0) + cand.relativeOffset.y;
+      const placedRect = this.findNonOverlappingPosition(
+        { x: baseX, y: baseY, width, height },
+        occupiedRects
+      );
+      occupiedRects.push(placedRect);
+      const inputs = (def?.inputs ?? []).map((h) => ({
+        id: h.id,
+        label: h.label || h.id,
+        type: "input",
+        dataType: h.dataType,
+        direction: "INPUT"
+      }));
+      const outputs = (def?.outputs ?? []).map((h) => ({
+        id: h.id,
+        label: h.label || h.id,
+        type: "output",
+        dataType: h.dataType,
+        direction: "OUTPUT"
+      }));
+      resolved.push({
+        id: cand.id,
+        nodeType: cand.nodeType,
+        label: cand.label,
+        position: { x: placedRect.x, y: placedRect.y },
+        size: { width, height },
+        scenarioIndex: cand.scenarioIndex,
+        sourceNodeId: cand.sourceNodeId,
+        socketMappings: cand.socketMappings,
+        inputs,
+        outputs
+      });
+    }
+    return resolved;
+  }
+  static findNonOverlappingPosition(ideal, existing) {
+    let curr = { ...ideal };
+    let collision = true;
+    let attempts = 0;
+    const padding = 20;
+    while (collision && attempts < 15) {
+      collision = false;
+      for (const box of existing) {
+        if (this.intersects(curr, box, padding)) {
+          collision = true;
+          curr.y = box.y + box.height + padding;
+          curr.x = ideal.x + (attempts % 2 === 1 ? 24 : 0);
+          break;
+        }
+      }
+      attempts++;
+    }
+    return curr;
+  }
+  static intersects(a, b, pad) {
+    return !(a.x + a.width + pad <= b.x || b.x + b.width + pad <= a.x || a.y + a.height + pad <= b.y || b.y + b.height + pad <= a.y);
+  }
+};
+
+// src/spatial/prediction/GhostTracePathBuilder.ts
+var GhostTracePathBuilder = class {
+  static buildGhostTraces(ghostNodes, existingNodes) {
+    const nodeMap = new Map(existingNodes.map((n) => [n.id, n]));
+    const traces = [];
+    for (const ghost of ghostNodes) {
+      const source = nodeMap.get(ghost.sourceNodeId);
+      if (!source) continue;
+      for (const mapping of ghost.socketMappings) {
+        const start = this.getRealSocketPosition(source, mapping.sourceSocketId, "output");
+        const end = this.getGhostSocketPosition(ghost, mapping.targetSocketId, "input");
+        const pathD = this.renderBezier(start.x, start.y, end.x, end.y);
+        traces.push({
+          id: `trace-ghost-${source.id}-${mapping.sourceSocketId}->${ghost.id}-${mapping.targetSocketId}`,
+          sourceNodeId: source.id,
+          sourceSocketId: mapping.sourceSocketId,
+          targetGhostNodeId: ghost.id,
+          targetSocketId: mapping.targetSocketId,
+          wireType: mapping.wireType,
+          pathD,
+          scenarioIndex: ghost.scenarioIndex
+        });
+      }
+    }
+    return traces;
+  }
+  static getRealSocketPosition(node, socketId, type) {
+    const sockets = type === "input" ? node.inputs : node.outputs;
+    const socket = sockets?.find((s) => s.id === socketId);
+    const index = sockets && socket ? sockets.indexOf(socket) : 0;
+    const w = node.width ?? 180;
+    const count = Math.max(1, sockets?.length ?? 1);
+    const x = type === "input" ? node.position.x : node.position.x + w;
+    const y = node.position.y + (index + 1) * (node.height ?? 120) / (count + 1);
+    return {
+      x: x + (socket?.offset?.x ?? 0),
+      y: y + (socket?.offset?.y ?? 0)
+    };
+  }
+  static getGhostSocketPosition(ghost, socketId, type) {
+    const sockets = type === "input" ? ghost.inputs : ghost.outputs;
+    const socket = sockets?.find((s) => s.id === socketId);
+    const index = sockets && socket ? sockets.indexOf(socket) : 0;
+    const w = ghost.size.width;
+    const count = Math.max(1, sockets?.length ?? 1);
+    const x = type === "input" ? ghost.position.x : ghost.position.x + w;
+    const y = ghost.position.y + (index + 1) * ghost.size.height / (count + 1);
+    return { x, y };
+  }
+  static renderBezier(startX, startY, endX, endY) {
+    const delta = Math.max(Math.abs(endX - startX) * 0.5, 45);
+    return `M ${startX},${startY} C ${startX + delta},${startY} ${endX - delta},${endY} ${endX},${endY}`;
+  }
+};
+
+export {
+  AttractionEngine,
+  calculateSocketCoordinates,
+  getBeamPoints,
+  useMagneticTraces,
+  GhostInferenceEngine,
+  GhostLayoutResolver,
+  GhostTracePathBuilder
+};

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

@@ -1,8 +1,8 @@
-import { B as BaseNode, a as BaseHandle, d as BaseNodeProps, D as DataHandle, N as NodePosition } from '../BaseNode-1HCEqmap.js';
-export { c as BaseHandleProps, C as ConnectionMode, e as CustomNode, H as HandleCategory, f as HandleDefinition, g as HandleDirection, h as HandleOffset, i as HandlePosition, j as NodeDefinition, b as NodeSize, V as ViewHandle } from '../BaseNode-1HCEqmap.js';
+import { b as BaseNode, B as BaseHandle, e as BaseNodeProps, D as DataHandle, N as NodePosition } from '../BaseNode-DTcd3K1B.js';
+export { d as BaseHandleProps, C as ConnectionMode, f as CustomNode, H as HandleCategory, g as HandleDefinition, c as HandleDirection, h as HandleOffset, i as HandlePosition, j as NodeDefinition, a as NodeSize, V as ViewHandle } from '../BaseNode-DTcd3K1B.js';
 import { B as BaseConnection } from '../BaseConnection-CMRrL6Fe.js';
 export { a as BaseConnectionProps, S as SolidConnection, b as SolidConnectionProps, V as ViewLink, c as ViewLinkProps } from '../BaseConnection-CMRrL6Fe.js';
-export { B as BaseGraph, a as BaseViewWindow, b as BaseViewWindowProps, C as CustomGraph, c as CustomViewWindow, D as DEFAULT_GRAPH_SETTINGS, d as DynamicState, G as GraphSettings, e as GraphView, f as Group, L as Landmark } from '../BaseGraph-Bl2f7Pqx.js';
+export { B as BaseGraph, a as BaseViewWindow, b as BaseViewWindowProps, C as CustomGraph, c as CustomViewWindow, D as DEFAULT_GRAPH_SETTINGS, d as DynamicState, G as GraphSettings, e as GraphView, f as Group, L as Landmark } from '../BaseGraph-BvkSYOTw.js';
 
 interface GroupNodeProps extends Partial<BaseNodeProps> {
     innerNodes?: BaseNode[];

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

@@ -2,19 +2,18 @@ import * as _ultrst_armada_krnl from '@ultrst-armada/krnl';
 import { ServiceDefinition } from '@ultrst-armada/krnl';
 export { LifecycleCycleError, LifecycleDescriptor, LifecycleGraph, LifecycleGraphNode, LifecycleScopeType, SKIPO_STATE, SkipoStateApi, SkipoStateEngine, StateDeclaration, StateEntry, StateUpdater, useLifecycleScope, useSkipoBind, useSkipoState } from './state/index.js';
 export { BullMQAdapter, BullMQAdapterOptions, CommandBus, CommandExecutionState, EnqueueOptions, ExecutionJob, ExecutionQueueAdapter, ExecutionResult, JobPriority, JobStatus, RetryPolicy, SKIPO_EXECUTION, SkipoCommand, SkipoExecutionEngine, useCommand } from './execution/index.js';
-import { B as BaseNode, D as DataHandle } from './BaseNode-1HCEqmap.js';
-export { a as BaseHandle, c as BaseHandleProps, d as BaseNodeProps, C as ConnectionMode, e as CustomNode, H as HandleCategory, f as HandleDefinition, g as HandleDirection, h as HandleOffset, i as HandlePosition, j as NodeDefinition, N as NodePosition, b as NodeSize, V as ViewHandle } from './BaseNode-1HCEqmap.js';
+import { b as BaseNode, D as DataHandle } from './BaseNode-DTcd3K1B.js';
+export { B as BaseHandle, d as BaseHandleProps, e as BaseNodeProps, C as ConnectionMode, f as CustomNode, H as HandleCategory, g as HandleDefinition, c as HandleDirection, h as HandleOffset, i as HandlePosition, j as NodeDefinition, N as NodePosition, a as NodeSize, V as ViewHandle } from './BaseNode-DTcd3K1B.js';
 import { S as SolidConnection } from './BaseConnection-CMRrL6Fe.js';
 export { B as BaseConnection, a as BaseConnectionProps, b as SolidConnectionProps, V as ViewLink, c as ViewLinkProps } from './BaseConnection-CMRrL6Fe.js';
-export { B as BaseGraph, a as BaseViewWindow, b as BaseViewWindowProps, C as CustomGraph, c as CustomViewWindow, D as DEFAULT_GRAPH_SETTINGS, d as DynamicState, G as GraphSettings, e as GraphView, f as Group } from './BaseGraph-Bl2f7Pqx.js';
+export { B as BaseGraph, a as BaseViewWindow, b as BaseViewWindowProps, C as CustomGraph, c as CustomViewWindow, D as DEFAULT_GRAPH_SETTINGS, d as DynamicState, G as GraphSettings, e as GraphView, f as Group } from './BaseGraph-BvkSYOTw.js';
 export { GroupNode as DomainGroupNode, SubgraphNode as DomainSubgraphNode, GroupNodeProps, SignalVariant, SubgraphNodeProps, instantiateSubgraph } from './domain/index.js';
 export { ConnectionRuleStore, HandleDescriptor, HandleTypeDefinition, HandleTypeRegistry, WireTypeDefinition, WireTypeRegistry, initializeDefaultGraphRules } from './rules/index.js';
-export { a as CompatibilityMatrix, C as CompatibilityResolution, b as CompatibilityResolverDelegate, c as CompatibilityRule } from './CompatibilityMatrix-DX307_vS.js';
-export { AttractionEngine, AutoSolidify, SocketCoordOptions, SocketCoordResult, SpatialEngine, calculateSocketCoordinates, getBeamPoints } from './spatial/index.js';
-import { T as Trace } from './TraceEngine-CJVpUb80.js';
-export { a as TraceEngine } from './TraceEngine-CJVpUb80.js';
-import { V as ViewportState, N as NodeGraphConfig, G as GraphNode } from './index-CiekWEH3.js';
-export { C as CommandApi, a as GhostStore, b as GhostStoreListener, c as GraphEdge, d as GraphListener, e as GraphStore, f as NodeGraphPlugin, S as Socket, g as SocketType } from './index-CiekWEH3.js';
+export { a as CompatibilityMatrix, C as CompatibilityResolution, b as CompatibilityResolverDelegate, c as CompatibilityRule } from './CompatibilityMatrix-Dj-tCWUA.js';
+export { AttractionEngine, AutoSolidify, GhostInferenceEngine, GhostLayoutResolver, GhostTracePathBuilder, MagneticTraceRecord, SocketCoordOptions, SocketCoordResult, SpatialEngine, UseMagneticTracesParams, calculateSocketCoordinates, getBeamPoints, useMagneticTraces } from './spatial/index.js';
+import { V as ViewportState, N as NodeGraphConfig, G as GraphNode, T as Trace } from './types-VDoc4FIc.js';
+export { a as GhostCandidate, b as GhostInferenceOptions, c as GhostNodeRecord, d as GhostSocketMapping, e as GhostTraceRecord, f as GraphEdge, g as NodeGraphPlugin, S as Socket, h as SocketType, i as TraceEngine } from './types-VDoc4FIc.js';
+export { CommandApi, GhostStore, GhostStoreListener, GraphListener, GraphStore } from './store/index.js';
 import React from 'react';
 import 'zustand/vanilla';