@stephen-netu/design-system 0.1.0 → 0.2.1

package/dist/n0-node-graph/NodePort.svelte.d.ts

@@ -0,0 +1,18 @@
+import type { PortDefinition } from './types';
+import type { PortDragDetail, PortDropDetail } from './node-port-types';
+export type { PortDragDetail, PortDropDetail } from './node-port-types';
+interface NodePortProps {
+    nodeId: string;
+    port: PortDefinition;
+    position: {
+        x: number;
+        y: number;
+    };
+    connected: boolean;
+    onportdragstart?: (detail: PortDragDetail) => void;
+    onportdrop?: (detail: PortDropDetail) => void;
+}
+declare const NodePort: import("svelte").Component<NodePortProps, {}, "">;
+type NodePort = ReturnType<typeof NodePort>;
+export default NodePort;
+//# sourceMappingURL=NodePort.svelte.d.ts.map

package/dist/n0-node-graph/NodePort.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodePort.svelte.d.ts","sourceRoot":"","sources":["../../src/n0-node-graph/NodePort.svelte.ts"],"names":[],"mappings":"AAGE,OAAO,KAAK,EAAiB,cAAc,EAAE,MAAM,SAAS,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGxE,YAAY,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExE,UAAU,aAAa;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,cAAc,CAAC;IACrB,QAAQ,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACnC,SAAS,EAAE,OAAO,CAAC;IACnB,eAAe,CAAC,EAAE,CAAC,MAAM,EAAE,cAAc,KAAK,IAAI,CAAC;IACnD,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,cAAc,KAAK,IAAI,CAAC;CAC/C;AA0EH,QAAA,MAAM,QAAQ,mDAAwC,CAAC;AACvD,KAAK,QAAQ,GAAG,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAC;AAC5C,eAAe,QAAQ,CAAC"}

package/{src/n0-node-graph/index.ts → dist/n0-node-graph/index.d.ts}

@@ -1,29 +1,6 @@
-// N0 Node Graph — Barrel Export
-
-// Types
-export type {
-  PortScope,
-  ScopedPortType,
-  PortDirection,
-  PortDefinition,
-  NodeDefinition,
-  NodeInstance,
-  EdgeDefinition,
-  GraphSchema,
-  ValidationError,
-  ValidationResult,
-  Point,
-  Transform,
-  Size,
-} from './types';
-
-// Interaction types
+export type { PortScope, ScopedPortType, PortDirection, PortDefinition, NodeDefinition, NodeInstance, EdgeDefinition, GraphSchema, ValidationError, ValidationResult, Point, Transform, Size, } from './types';
 export type { PortDragDetail, PortDropDetail } from './node-port-types';
-
-// Validation
 export { validateGraph } from './validate';
-
-// Components
 export { default as NodeCanvas } from './NodeCanvas.svelte';
 export { default as Node } from './Node.svelte';
 export { default as NodePort } from './NodePort.svelte';
@@ -31,3 +8,4 @@ export { default as NodeEdge } from './NodeEdge.svelte';
 export { default as GraphEditor } from './GraphEditor.svelte';
 export { default as NodePalette } from './NodePalette.svelte';
 export { default as GraphHistory } from './GraphHistory.svelte';
+//# sourceMappingURL=index.d.ts.map

package/dist/n0-node-graph/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/n0-node-graph/index.ts"],"names":[],"mappings":"AAGA,YAAY,EACV,SAAS,EACT,cAAc,EACd,aAAa,EACb,cAAc,EACd,cAAc,EACd,YAAY,EACZ,cAAc,EACd,WAAW,EACX,eAAe,EACf,gBAAgB,EAChB,KAAK,EACL,SAAS,EACT,IAAI,GACL,MAAM,SAAS,CAAC;AAGjB,YAAY,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGxE,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAG3C,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/n0-node-graph/index.js

@@ -0,0 +1,11 @@
+// N0 Node Graph — Barrel Export
+// Validation
+export { validateGraph } from './validate';
+// Components
+export { default as NodeCanvas } from './NodeCanvas.svelte';
+export { default as Node } from './Node.svelte';
+export { default as NodePort } from './NodePort.svelte';
+export { default as NodeEdge } from './NodeEdge.svelte';
+export { default as GraphEditor } from './GraphEditor.svelte';
+export { default as NodePalette } from './NodePalette.svelte';
+export { default as GraphHistory } from './GraphHistory.svelte';

package/dist/n0-node-graph/n0-tokens.css

@@ -0,0 +1,29 @@
+/* N0 Node Graph — CSS Design Tokens */
+:root {
+  /* Canvas */
+  --n0-canvas-bg: var(--color-bg-canvas, #1a1a1a);
+  --n0-canvas-grid: rgba(255, 255, 255, 0.03);
+  --n0-canvas-grid-size: 20px;
+
+  /* Nodes */
+  --n0-node-bg: var(--color-bg-panel, #222);
+  --n0-node-border: var(--color-accent-subtle, rgba(184, 115, 51, 0.2));
+  --n0-node-border-selected: var(--color-accent, #b87333);
+  --n0-node-header-bg: var(--color-accent-subtle, rgba(184, 115, 51, 0.1));
+  --n0-node-radius: 8px;
+  --n0-node-min-width: 180px;
+  --n0-node-max-width: 400px;
+
+  /* Ports */
+  --n0-port-radius: 6px;
+  --n0-port-color-input: #7aa2f7;
+  --n0-port-color-output: #9ece6a;
+  --n0-port-color-incompatible: #c0392b;
+  --n0-port-hover-scale: 1.3;
+
+  /* Edges */
+  --n0-edge-width: 2px;
+  --n0-edge-color: var(--color-accent-muted, rgba(184, 115, 51, 0.4));
+  --n0-edge-color-hover: var(--color-accent, #b87333);
+  --n0-edge-color-creating: var(--color-accent-muted, rgba(184, 115, 51, 0.6));
+}

package/dist/n0-node-graph/node-port-types.d.ts

@@ -0,0 +1,18 @@
+import type { PortDirection } from './types';
+export interface PortDragDetail {
+    nodeId: string;
+    portId: string;
+    direction: PortDirection;
+    type: string;
+    position: {
+        x: number;
+        y: number;
+    };
+}
+export interface PortDropDetail {
+    nodeId: string;
+    portId: string;
+    direction: PortDirection;
+    type: string;
+}
+//# sourceMappingURL=node-port-types.d.ts.map

package/dist/n0-node-graph/node-port-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-port-types.d.ts","sourceRoot":"","sources":["../../src/n0-node-graph/node-port-types.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,aAAa,CAAC;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACpC;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,aAAa,CAAC;IACzB,IAAI,EAAE,MAAM,CAAC;CACd"}

package/dist/n0-node-graph/node-port-types.js

@@ -0,0 +1,3 @@
+// N0 Node Graph — Port interaction types
+// Extracted from NodePort.svelte so tsc can resolve them without Svelte type declarations.
+export {};

package/dist/n0-node-graph/types.d.ts

@@ -0,0 +1,61 @@
+import type { Point, Size } from '../p0-primitives/types/geometry';
+export type { Point, Size };
+export type PortScope = 'realm' | 'grove' | 'accord' | 'system' | 'app';
+export type ScopedPortType = `${PortScope}:${string}:${string}`;
+export type PortDirection = 'input' | 'output';
+export interface PortDefinition {
+    id: string;
+    label: string;
+    type: ScopedPortType;
+    direction: PortDirection;
+    required: boolean;
+    maxConnections: number;
+}
+export interface NodeDefinition {
+    kind: string;
+    label: string;
+    description: string;
+    ports: PortDefinition[];
+    metadata: Record<string, unknown>;
+}
+export interface NodeInstance {
+    id: string;
+    kind: string;
+    position: Point;
+    size: Size;
+    data: Record<string, unknown>;
+    collapsed: boolean;
+}
+export interface EdgeDefinition {
+    id: string;
+    sourceNodeId: string;
+    sourcePortId: string;
+    targetNodeId: string;
+    targetPortId: string;
+    metadata: Record<string, unknown>;
+}
+export interface GraphSchema {
+    id: string;
+    name: string;
+    version: string;
+    nodeDefinitions: NodeDefinition[];
+    nodes: NodeInstance[];
+    edges: EdgeDefinition[];
+}
+export interface ValidationError {
+    code: string;
+    message: string;
+    nodeId?: string;
+    edgeId?: string;
+    portId?: string;
+}
+export interface ValidationResult {
+    valid: boolean;
+    errors: ValidationError[];
+}
+export interface Transform {
+    x: number;
+    y: number;
+    scale: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/n0-node-graph/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/n0-node-graph/types.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,iCAAiC,CAAC;AAEnE,YAAY,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAI5B,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,GAAG,KAAK,CAAC;AAGxE,MAAM,MAAM,cAAc,GAAG,GAAG,SAAS,IAAI,MAAM,IAAI,MAAM,EAAE,CAAC;AAEhE,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,QAAQ,CAAC;AAI/C,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,cAAc,CAAC;IACrB,SAAS,EAAE,aAAa,CAAC;IACzB,QAAQ,EAAE,OAAO,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;CACxB;AAID,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,KAAK,CAAC;IAChB,IAAI,EAAE,IAAI,CAAC;IACX,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,SAAS,EAAE,OAAO,CAAC;CACpB;AAID,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAID,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,cAAc,EAAE,CAAC;IAClC,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,KAAK,EAAE,cAAc,EAAE,CAAC;CACzB;AAID,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,eAAe,EAAE,CAAC;CAC3B;AAID,MAAM,WAAW,SAAS;IACxB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;CACf"}

package/dist/n0-node-graph/types.js

@@ -0,0 +1,3 @@
+// N0 Node Graph — Schema Layer Types
+// Pure TypeScript — no Svelte, no DOM dependencies
+export {};

package/dist/n0-node-graph/validate.d.ts

@@ -0,0 +1,11 @@
+import type { GraphSchema, ValidationResult } from './types';
+/**
+ * Validates a graph schema against all 8 validation rules.
+ *
+ * Pure function — no side effects, no mutation of input.
+ *
+ * @param schema - The graph schema to validate
+ * @returns ValidationResult with valid flag and array of errors
+ */
+export declare function validateGraph(schema: GraphSchema): ValidationResult;
+//# sourceMappingURL=validate.d.ts.map

package/dist/n0-node-graph/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/n0-node-graph/validate.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,WAAW,EAMX,gBAAgB,EACjB,MAAM,SAAS,CAAC;AA8UjB;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,WAAW,GAAG,gBAAgB,CAiBnE"}

package/dist/n0-node-graph/validate.js

@@ -0,0 +1,270 @@
+// N0 Node Graph — Validation
+// Pure TypeScript — no side effects, no mutations
+// Helper: Get a node definition by kind
+function getNodeDefinition(nodeDefinitions, kind) {
+    return nodeDefinitions.find((def) => def.kind === kind);
+}
+// Helper: Get a node instance by id
+function getNodeInstance(nodes, id) {
+    return nodes.find((node) => node.id === id);
+}
+// Helper: Get a port definition from a node definition
+function getPortDefinition(nodeDefinition, portId) {
+    return nodeDefinition.ports.find((port) => port.id === portId);
+}
+// Helper: Count connections to a specific port
+function countConnectionsToPort(edges, nodeId, portId, direction) {
+    return edges.filter((edge) => {
+        if (direction === 'source') {
+            return edge.sourceNodeId === nodeId && edge.sourcePortId === portId;
+        }
+        return edge.targetNodeId === nodeId && edge.targetPortId === portId;
+    }).length;
+}
+// Helper: Check if an edge is a duplicate
+function isDuplicateEdge(edges, edge) {
+    return edges.some((existing) => existing.id !== edge.id &&
+        existing.sourceNodeId === edge.sourceNodeId &&
+        existing.sourcePortId === edge.sourcePortId &&
+        existing.targetNodeId === edge.targetNodeId &&
+        existing.targetPortId === edge.targetPortId);
+}
+// Validation Rule 1: NodeInstance.kind must reference a registered NodeDefinition.kind
+function validateNodeKindReferences(schema) {
+    const errors = [];
+    for (const node of schema.nodes) {
+        const definition = getNodeDefinition(schema.nodeDefinitions, node.kind);
+        if (!definition) {
+            errors.push({
+                code: 'INVALID_NODE_KIND',
+                message: `Node instance "${node.id}" references undefined kind "${node.kind}"`,
+                nodeId: node.id,
+            });
+        }
+    }
+    return errors;
+}
+// Validation Rule 2: Every edge must connect existing nodes and existing ports
+function validateEdgeConnections(schema) {
+    const errors = [];
+    for (const edge of schema.edges) {
+        // Check source node exists
+        const sourceNode = getNodeInstance(schema.nodes, edge.sourceNodeId);
+        if (!sourceNode) {
+            errors.push({
+                code: 'INVALID_SOURCE_NODE',
+                message: `Edge "${edge.id}" references non-existent source node "${edge.sourceNodeId}"`,
+                edgeId: edge.id,
+            });
+            continue;
+        }
+        // Check target node exists
+        const targetNode = getNodeInstance(schema.nodes, edge.targetNodeId);
+        if (!targetNode) {
+            errors.push({
+                code: 'INVALID_TARGET_NODE',
+                message: `Edge "${edge.id}" references non-existent target node "${edge.targetNodeId}"`,
+                edgeId: edge.id,
+            });
+            continue;
+        }
+        // Get node definitions
+        const sourceDef = getNodeDefinition(schema.nodeDefinitions, sourceNode.kind);
+        const targetDef = getNodeDefinition(schema.nodeDefinitions, targetNode.kind);
+        if (!sourceDef) {
+            errors.push({
+                code: 'INVALID_SOURCE_NODE_KIND',
+                message: `Source node "${sourceNode.id}" has no registered definition`,
+                edgeId: edge.id,
+                nodeId: sourceNode.id,
+            });
+            continue;
+        }
+        if (!targetDef) {
+            errors.push({
+                code: 'INVALID_TARGET_NODE_KIND',
+                message: `Target node "${targetNode.id}" has no registered definition`,
+                edgeId: edge.id,
+                nodeId: targetNode.id,
+            });
+            continue;
+        }
+        // Check source port exists
+        const sourcePort = getPortDefinition(sourceDef, edge.sourcePortId);
+        if (!sourcePort) {
+            errors.push({
+                code: 'INVALID_SOURCE_PORT',
+                message: `Edge "${edge.id}" references non-existent source port "${edge.sourcePortId}" on node "${sourceNode.id}"`,
+                edgeId: edge.id,
+                portId: edge.sourcePortId,
+            });
+        }
+        // Check target port exists
+        const targetPort = getPortDefinition(targetDef, edge.targetPortId);
+        if (!targetPort) {
+            errors.push({
+                code: 'INVALID_TARGET_PORT',
+                message: `Edge "${edge.id}" references non-existent target port "${edge.targetPortId}" on node "${targetNode.id}"`,
+                edgeId: edge.id,
+                portId: edge.targetPortId,
+            });
+        }
+    }
+    return errors;
+}
+// Validation Rule 3: Port direction — edges go from output port to input port only
+function validatePortDirection(schema) {
+    const errors = [];
+    for (const edge of schema.edges) {
+        const sourceNode = getNodeInstance(schema.nodes, edge.sourceNodeId);
+        const targetNode = getNodeInstance(schema.nodes, edge.targetNodeId);
+        if (!sourceNode || !targetNode)
+            continue;
+        const sourceDef = getNodeDefinition(schema.nodeDefinitions, sourceNode.kind);
+        const targetDef = getNodeDefinition(schema.nodeDefinitions, targetNode.kind);
+        if (!sourceDef || !targetDef)
+            continue;
+        const sourcePort = getPortDefinition(sourceDef, edge.sourcePortId);
+        const targetPort = getPortDefinition(targetDef, edge.targetPortId);
+        if (sourcePort && targetPort) {
+            if (sourcePort.direction !== 'output') {
+                errors.push({
+                    code: 'INVALID_PORT_DIRECTION',
+                    message: `Edge "${edge.id}" must start from an output port, but port "${edge.sourcePortId}" on node "${sourceNode.id}" is "${sourcePort.direction}"`,
+                    edgeId: edge.id,
+                    portId: edge.sourcePortId,
+                });
+            }
+            if (targetPort.direction !== 'input') {
+                errors.push({
+                    code: 'INVALID_PORT_DIRECTION',
+                    message: `Edge "${edge.id}" must end at an input port, but port "${edge.targetPortId}" on node "${targetNode.id}" is "${targetPort.direction}"`,
+                    edgeId: edge.id,
+                    portId: edge.targetPortId,
+                });
+            }
+        }
+    }
+    return errors;
+}
+// Validation Rule 4: Port type compatibility — exact match required
+function validateTypeCompatibility(schema) {
+    const errors = [];
+    for (const edge of schema.edges) {
+        const sourceNode = getNodeInstance(schema.nodes, edge.sourceNodeId);
+        const targetNode = getNodeInstance(schema.nodes, edge.targetNodeId);
+        if (!sourceNode || !targetNode)
+            continue;
+        const sourceDef = getNodeDefinition(schema.nodeDefinitions, sourceNode.kind);
+        const targetDef = getNodeDefinition(schema.nodeDefinitions, targetNode.kind);
+        if (!sourceDef || !targetDef)
+            continue;
+        const sourcePort = getPortDefinition(sourceDef, edge.sourcePortId);
+        const targetPort = getPortDefinition(targetDef, edge.targetPortId);
+        if (sourcePort && targetPort && sourcePort.type !== targetPort.type) {
+            errors.push({
+                code: 'TYPE_MISMATCH',
+                message: `Edge "${edge.id}" connects incompatible types: source port "${edge.sourcePortId}" has type "${sourcePort.type}" but target port "${edge.targetPortId}" has type "${targetPort.type}"`,
+                edgeId: edge.id,
+            });
+        }
+    }
+    return errors;
+}
+// Validation Rule 5: Connection limits — port.maxConnections not exceeded
+function validateConnectionLimits(schema) {
+    const errors = [];
+    for (const node of schema.nodes) {
+        const definition = getNodeDefinition(schema.nodeDefinitions, node.kind);
+        if (!definition)
+            continue;
+        for (const port of definition.ports) {
+            const connectionCount = countConnectionsToPort(schema.edges, node.id, port.id, port.direction === 'output' ? 'source' : 'target');
+            if (connectionCount > port.maxConnections) {
+                errors.push({
+                    code: 'MAX_CONNECTIONS_EXCEEDED',
+                    message: `Port "${port.id}" on node "${node.id}" has ${connectionCount} connections but maximum allowed is ${port.maxConnections}`,
+                    nodeId: node.id,
+                    portId: port.id,
+                });
+            }
+        }
+    }
+    return errors;
+}
+// Validation Rule 6: Required ports — all required:true ports must have at least one connection
+function validateRequiredPorts(schema) {
+    const errors = [];
+    for (const node of schema.nodes) {
+        const definition = getNodeDefinition(schema.nodeDefinitions, node.kind);
+        if (!definition)
+            continue;
+        for (const port of definition.ports) {
+            if (!port.required)
+                continue;
+            const connectionCount = countConnectionsToPort(schema.edges, node.id, port.id, port.direction === 'output' ? 'source' : 'target');
+            if (connectionCount === 0) {
+                errors.push({
+                    code: 'REQUIRED_PORT_UNCONNECTED',
+                    message: `Required port "${port.id}" on node "${node.id}" has no connections`,
+                    nodeId: node.id,
+                    portId: port.id,
+                });
+            }
+        }
+    }
+    return errors;
+}
+// Validation Rule 7: No self-loops (edge source === edge target on same node)
+function validateNoSelfLoops(schema) {
+    const errors = [];
+    for (const edge of schema.edges) {
+        if (edge.sourceNodeId === edge.targetNodeId) {
+            errors.push({
+                code: 'SELF_LOOP',
+                message: `Edge "${edge.id}" creates a self-loop on node "${edge.sourceNodeId}"`,
+                edgeId: edge.id,
+            });
+        }
+    }
+    return errors;
+}
+// Validation Rule 8: No duplicate edges (same source port → same target port)
+function validateNoDuplicateEdges(schema) {
+    const errors = [];
+    for (const edge of schema.edges) {
+        if (isDuplicateEdge(schema.edges, edge)) {
+            errors.push({
+                code: 'DUPLICATE_EDGE',
+                message: `Edge "${edge.id}" is a duplicate: same source "${edge.sourceNodeId}:${edge.sourcePortId}" to target "${edge.targetNodeId}:${edge.targetPortId}"`,
+                edgeId: edge.id,
+            });
+        }
+    }
+    return errors;
+}
+/**
+ * Validates a graph schema against all 8 validation rules.
+ *
+ * Pure function — no side effects, no mutation of input.
+ *
+ * @param schema - The graph schema to validate
+ * @returns ValidationResult with valid flag and array of errors
+ */
+export function validateGraph(schema) {
+    // Collect all errors from all validation rules
+    const allErrors = [
+        ...validateNodeKindReferences(schema),
+        ...validateEdgeConnections(schema),
+        ...validatePortDirection(schema),
+        ...validateTypeCompatibility(schema),
+        ...validateConnectionLimits(schema),
+        ...validateRequiredPorts(schema),
+        ...validateNoSelfLoops(schema),
+        ...validateNoDuplicateEdges(schema),
+    ];
+    return {
+        valid: allErrors.length === 0,
+        errors: allErrors,
+    };
+}