pmx-canvas 0.4.6 → 0.4.7

package/src/server/canvas-validation.ts

@@ -1,46 +1,11 @@
 import type { CanvasLayout, CanvasNodeState } from './canvas-state.js';
 import { getCanvasNodeTitle } from './canvas-serialization.js';
+// The readability floor is SHARED with the client: the server clamps it at
+// creation and `validate` reports violations, but the browser's auto-fit must
+// honor the same floor or it silently undoes the clamp (0.4.6 Finding AA).
+import { nodeMinSize } from '../shared/node-sizes.js';
 
-/**
- * Per-type minimum node size (0.4.5 report follow-up): agents frequently
- * create nodes with explicit frames far too small for their content — clipped
- * markdown, charts squeezed behind inner scrollbars. Explicit sizes below the
- * floor are clamped UP at creation (canvas-operations.ts creators);
- * `strictSize: true` is the escape hatch for a genuinely small fixed frame.
- * Floors sit below every type default and above the point of unreadability.
- * Creation-only: later updates are untouched (the browser's drag-resize
- * enforces its own 200×100 floor client-side), but `validate` reports any
- * node below its floor as an advisory sizeWarning. Absent types (trace,
- * group, prompt/response) are intentionally unclamped — trace is small by
- * design, groups size to their children.
- */
-export const NODE_MIN_CREATE_SIZES: Partial<Record<CanvasNodeState['type'], { width: number; height: number }>> = {
-  markdown: { width: 360, height: 180 },
-  context: { width: 360, height: 180 },
-  file: { width: 360, height: 200 },
-  diff: { width: 420, height: 240 },
-  mermaid: { width: 360, height: 240 },
-  status: { width: 280, height: 120 },
-  ledger: { width: 320, height: 200 },
-  image: { width: 240, height: 180 },
-  html: { width: 420, height: 280 },
-  webpage: { width: 420, height: 280 },
-  'json-render': { width: 420, height: 280 },
-  graph: { width: 420, height: 280 },
-  'mcp-app': { width: 480, height: 320 },
-};
-
-export function clampCreateNodeSize(
-  type: CanvasNodeState['type'],
-  width: number,
-  height: number,
-  strictSize?: boolean,
-): { width: number; height: number } {
-  if (strictSize === true) return { width, height };
-  const min = NODE_MIN_CREATE_SIZES[type];
-  if (!min) return { width, height };
-  return { width: Math.max(width, min.width), height: Math.max(height, min.height) };
-}
+export { NODE_MIN_SIZES, clampCreateNodeSize, nodeMinSize } from '../shared/node-sizes.js';
 
 export interface CanvasValidationPair {
   aId: string;
@@ -66,12 +31,26 @@ export interface CanvasSizeWarning {
   minHeight: number;
 }
 
+export interface CanvasHiddenEdgeEndpoint {
+  edgeId: string;
+  nodeId: string;
+  nodeTitle: string | null;
+  dockPosition: 'left' | 'right';
+}
+
 export interface CanvasValidationResult {
   ok: boolean;
   collisions: CanvasValidationPair[];
   containments: CanvasContainmentIssue[];
   containmentViolations: CanvasContainmentIssue[];
   missingEdgeEndpoints: Array<{ edgeId: string; from: string; to: string }>;
+  /**
+   * Edges whose endpoint node is DOCKED — it renders in the HUD column, not on
+   * the canvas, so the edge visually terminates in empty space even though both
+   * endpoint IDs resolve (0.4.6 orb feedback #1). Advisory: reported for
+   * diagnosis, but does NOT fail `ok` (see the note at the return site).
+   */
+  hiddenEdgeEndpoints: CanvasHiddenEdgeEndpoint[];
   /** Nodes below their type's readable minimum (advisory — does not fail `ok`). */
   sizeWarnings: CanvasSizeWarning[];
   summary: {
@@ -81,6 +60,7 @@ export interface CanvasValidationResult {
     containments: number;
     containmentViolations: number;
     missingEdgeEndpoints: number;
+    hiddenEdgeEndpoints: number;
     sizeWarnings: number;
   };
 }
@@ -163,6 +143,28 @@ export function validateCanvasLayout(layout: CanvasLayout): CanvasValidationResu
     .filter((edge) => !nodeIds.has(edge.from) || !nodeIds.has(edge.to))
     .map((edge) => ({ edgeId: edge.id, from: edge.from, to: edge.to }));
 
+  // An edge to a DOCKED node cannot be drawn: docked nodes live in the HUD
+  // column, and the world-space edge layer skips them, so the edge trails off
+  // into empty canvas. Structural validation used to miss this entirely because
+  // both endpoint IDs resolve (0.4.6 orb feedback #1).
+  const dockedById = new Map(
+    layout.nodes.filter((node) => node.dockPosition != null).map((node) => [node.id, node] as const),
+  );
+  const hiddenEdgeEndpoints: CanvasHiddenEdgeEndpoint[] = layout.edges.flatMap((edge) =>
+    [edge.from, edge.to].flatMap((nodeId) => {
+      const docked = dockedById.get(nodeId);
+      if (!docked || docked.dockPosition == null) return [];
+      return [
+        {
+          edgeId: edge.id,
+          nodeId,
+          nodeTitle: getCanvasNodeTitle(docked),
+          dockPosition: docked.dockPosition,
+        },
+      ];
+    }),
+  );
+
   // Advisory: nodes below their type's readable floor (clipped/unreadable
   // content — 0.4.5 report follow-up). Creation clamps these, but resized or
   // strictSize-created nodes can still be undersized; surface them so an
@@ -171,7 +173,7 @@ export function validateCanvasLayout(layout: CanvasLayout): CanvasValidationResu
   const sizeWarnings: CanvasSizeWarning[] = layout.nodes
     .filter((node) => !node.collapsed && node.dockPosition == null && node.data?.strictSize !== true)
     .flatMap((node) => {
-      const min = NODE_MIN_CREATE_SIZES[node.type];
+      const min = nodeMinSize(node.type);
       if (!min || (node.size.width >= min.width && node.size.height >= min.height)) return [];
       return [
         {
@@ -187,11 +189,17 @@ export function validateCanvasLayout(layout: CanvasLayout): CanvasValidationResu
     });
 
   return {
+    // `hiddenEdgeEndpoints` is ADVISORY (like sizeWarnings): a docked endpoint
+    // is a rendering observation, not a structural defect, and folding it into
+    // `ok` would flip previously-healthy boards to ok:false with no user change
+    // — `ok` is a documented response field of a frozen surface, so that is a
+    // contract break, not a patch. It is still reported for diagnosis.
     ok: collisions.length === 0 && containmentViolations.length === 0 && missingEdgeEndpoints.length === 0,
     collisions,
     containments,
     containmentViolations,
     missingEdgeEndpoints,
+    hiddenEdgeEndpoints,
     sizeWarnings,
     summary: {
       nodes: layout.nodes.length,
@@ -200,6 +208,7 @@ export function validateCanvasLayout(layout: CanvasLayout): CanvasValidationResu
       containments: containments.length,
       containmentViolations: containmentViolations.length,
       missingEdgeEndpoints: missingEdgeEndpoints.length,
+      hiddenEdgeEndpoints: hiddenEdgeEndpoints.length,
       sizeWarnings: sizeWarnings.length,
     },
   };