@principal-ai/principal-view-cli 0.1.13 → 0.1.15

package/dist/index.cjs

@@ -13464,18 +13464,162 @@ function loadLibrary(principalViewsDir) {
         if (library && typeof library === "object") {
           return {
             nodeComponents: library.nodeComponents || {},
-            edgeComponents: library.edgeComponents || {}
+            edgeComponents: library.edgeComponents || {},
+            raw: library,
+            path: libraryPath
           };
         }
       } catch {
-        return { nodeComponents: {}, edgeComponents: {} };
+        return { nodeComponents: {}, edgeComponents: {}, raw: {}, path: libraryPath };
       }
     }
   }
   return null;
 }
+function validateLibrary(library) {
+  const issues = [];
+  const lib = library.raw;
+  checkUnknownFields(lib, ALLOWED_LIBRARY_FIELDS.root, "", issues);
+  if (lib.nodeComponents && typeof lib.nodeComponents === "object") {
+    for (const [compId, compDef] of Object.entries(lib.nodeComponents)) {
+      if (compDef && typeof compDef === "object") {
+        const comp = compDef;
+        checkUnknownFields(comp, ALLOWED_LIBRARY_FIELDS.nodeComponent, `nodeComponents.${compId}`, issues);
+        if (comp.size && typeof comp.size === "object") {
+          checkUnknownFields(comp.size, ALLOWED_LIBRARY_FIELDS.nodeComponentSize, `nodeComponents.${compId}.size`, issues);
+        }
+        if (comp.states && typeof comp.states === "object") {
+          for (const [stateId, stateDef] of Object.entries(comp.states)) {
+            if (stateDef && typeof stateDef === "object") {
+              checkUnknownFields(stateDef, ALLOWED_LIBRARY_FIELDS.nodeComponentState, `nodeComponents.${compId}.states.${stateId}`, issues);
+            }
+          }
+        }
+        if (comp.dataSchema && typeof comp.dataSchema === "object") {
+          for (const [fieldName, fieldDef] of Object.entries(comp.dataSchema)) {
+            if (fieldDef && typeof fieldDef === "object") {
+              checkUnknownFields(fieldDef, ALLOWED_LIBRARY_FIELDS.nodeComponentDataSchemaField, `nodeComponents.${compId}.dataSchema.${fieldName}`, issues);
+            }
+          }
+        }
+        if (comp.layout && typeof comp.layout === "object") {
+          checkUnknownFields(comp.layout, ALLOWED_LIBRARY_FIELDS.nodeComponentLayout, `nodeComponents.${compId}.layout`, issues);
+        }
+        if (Array.isArray(comp.actions)) {
+          comp.actions.forEach((action, actionIndex) => {
+            if (action && typeof action === "object") {
+              checkUnknownFields(action, ALLOWED_LIBRARY_FIELDS.nodeComponentAction, `nodeComponents.${compId}.actions[${actionIndex}]`, issues);
+            }
+          });
+        }
+      }
+    }
+  }
+  if (lib.edgeComponents && typeof lib.edgeComponents === "object") {
+    for (const [compId, compDef] of Object.entries(lib.edgeComponents)) {
+      if (compDef && typeof compDef === "object") {
+        const comp = compDef;
+        checkUnknownFields(comp, ALLOWED_LIBRARY_FIELDS.edgeComponent, `edgeComponents.${compId}`, issues);
+        if (comp.animation && typeof comp.animation === "object") {
+          checkUnknownFields(comp.animation, ALLOWED_LIBRARY_FIELDS.edgeComponentAnimation, `edgeComponents.${compId}.animation`, issues);
+        }
+        if (comp.label && typeof comp.label === "object") {
+          checkUnknownFields(comp.label, ALLOWED_LIBRARY_FIELDS.edgeComponentLabel, `edgeComponents.${compId}.label`, issues);
+        }
+      }
+    }
+  }
+  if (Array.isArray(lib.connectionRules)) {
+    lib.connectionRules.forEach((rule, ruleIndex) => {
+      if (rule && typeof rule === "object") {
+        const r = rule;
+        checkUnknownFields(r, ALLOWED_LIBRARY_FIELDS.connectionRule, `connectionRules[${ruleIndex}]`, issues);
+        if (r.constraints && typeof r.constraints === "object") {
+          checkUnknownFields(r.constraints, ALLOWED_LIBRARY_FIELDS.connectionRuleConstraints, `connectionRules[${ruleIndex}].constraints`, issues);
+        }
+      }
+    });
+  }
+  return issues;
+}
 var STANDARD_CANVAS_TYPES = ["text", "group", "file", "link"];
 var VALID_NODE_SHAPES = ["circle", "rectangle", "hexagon", "diamond", "custom"];
+var ALLOWED_CANVAS_FIELDS = {
+  root: ["nodes", "edges", "pv"],
+  pv: ["version", "name", "description", "nodeTypes", "edgeTypes", "pathConfig", "display"],
+  pvPathConfig: ["projectRoot", "captureSource", "enableActionPatterns", "logLevel", "ignoreUnsourced"],
+  pvDisplay: ["layout", "theme", "animations"],
+  pvDisplayTheme: ["primary", "success", "warning", "danger", "info"],
+  pvDisplayAnimations: ["enabled", "speed"],
+  pvNodeType: ["label", "description", "color", "icon", "shape"],
+  pvEdgeType: ["label", "style", "color", "width", "directed", "animation", "labelConfig", "activatedBy"],
+  pvEdgeTypeAnimation: ["type", "duration", "color"],
+  pvEdgeTypeLabelConfig: ["field", "position"],
+  // Base node fields from JSON Canvas spec
+  nodeBase: ["id", "type", "x", "y", "width", "height", "color", "pv"],
+  // Type-specific node fields
+  nodeText: ["text"],
+  nodeFile: ["file", "subpath"],
+  nodeLink: ["url"],
+  nodeGroup: ["label", "background", "backgroundStyle"],
+  // Node pv extension
+  nodePv: ["nodeType", "description", "shape", "icon", "fill", "stroke", "states", "sources", "actions", "dataSchema", "layout"],
+  nodePvState: ["color", "icon", "label"],
+  nodePvAction: ["pattern", "event", "state", "metadata", "triggerEdges"],
+  nodePvDataSchemaField: ["type", "required", "displayInLabel"],
+  nodePvLayout: ["layer", "cluster"],
+  // Edge fields
+  edge: ["id", "fromNode", "toNode", "fromSide", "toSide", "fromEnd", "toEnd", "color", "label", "pv"],
+  edgePv: ["edgeType", "style", "width", "animation", "activatedBy"],
+  edgePvAnimation: ["type", "duration", "color"],
+  edgePvActivatedBy: ["action", "animation", "direction", "duration"]
+};
+var ALLOWED_LIBRARY_FIELDS = {
+  root: ["version", "name", "description", "nodeComponents", "edgeComponents", "connectionRules"],
+  nodeComponent: ["description", "tags", "defaultLabel", "shape", "icon", "color", "size", "states", "sources", "actions", "dataSchema", "layout"],
+  nodeComponentSize: ["width", "height"],
+  nodeComponentState: ["color", "icon", "label"],
+  nodeComponentAction: ["pattern", "event", "state", "metadata", "triggerEdges"],
+  nodeComponentDataSchemaField: ["type", "required", "displayInLabel", "label", "displayInInfo"],
+  nodeComponentLayout: ["layer", "cluster"],
+  edgeComponent: ["description", "tags", "style", "color", "width", "directed", "animation", "label"],
+  edgeComponentAnimation: ["type", "duration", "color"],
+  edgeComponentLabel: ["field", "position"],
+  connectionRule: ["from", "to", "via", "constraints"],
+  connectionRuleConstraints: ["maxInstances", "bidirectional", "exclusive"]
+};
+function checkUnknownFields(obj, allowedFields, path4, issues) {
+  for (const field of Object.keys(obj)) {
+    if (!allowedFields.includes(field)) {
+      const suggestion = findSimilarField(field, allowedFields);
+      issues.push({
+        type: "error",
+        message: `Unknown field "${field}"${path4 ? ` in ${path4}` : " at root level"}`,
+        path: path4 ? `${path4}.${field}` : field,
+        suggestion: suggestion ? `Did you mean "${suggestion}"? Allowed fields: ${allowedFields.join(", ")}` : `Allowed fields: ${allowedFields.join(", ")}`
+      });
+    }
+  }
+}
+function findSimilarField(field, allowedFields) {
+  const fieldLower = field.toLowerCase();
+  for (const allowed of allowedFields) {
+    const allowedLower = allowed.toLowerCase();
+    if (fieldLower.includes(allowedLower) || allowedLower.includes(fieldLower)) {
+      return allowed;
+    }
+    if (Math.abs(field.length - allowed.length) <= 2) {
+      let differences = 0;
+      const minLen = Math.min(fieldLower.length, allowedLower.length);
+      for (let i = 0; i < minLen; i++) {
+        if (fieldLower[i] !== allowedLower[i]) differences++;
+      }
+      differences += Math.abs(field.length - allowed.length);
+      if (differences <= 2) return allowed;
+    }
+  }
+  return null;
+}
 function validateCanvas(canvas, filePath, library) {
   const issues = [];
   if (!canvas || typeof canvas !== "object") {
@@ -13483,6 +13627,7 @@ function validateCanvas(canvas, filePath, library) {
     return issues;
   }
   const c = canvas;
+  checkUnknownFields(c, ALLOWED_CANVAS_FIELDS.root, "", issues);
   const libraryNodeTypes = library ? Object.keys(library.nodeComponents) : [];
   const libraryEdgeTypes = library ? Object.keys(library.edgeComponents) : [];
   let canvasEdgeTypes = [];
@@ -13498,6 +13643,7 @@ function validateCanvas(canvas, filePath, library) {
     issues.push({ type: "error", message: '"pv" extension must be an object' });
   } else {
     const pv = c.pv;
+    checkUnknownFields(pv, ALLOWED_CANVAS_FIELDS.pv, "pv", issues);
     if (typeof pv.version !== "string" || !pv.version) {
       issues.push({
         type: "error",
@@ -13514,11 +13660,41 @@ function validateCanvas(canvas, filePath, library) {
         suggestion: 'Add: "name": "My Graph"'
       });
     }
-    if (pv.edgeTypes && typeof pv.edgeTypes === "object") {
-      canvasEdgeTypes = Object.keys(pv.edgeTypes);
+    if (pv.pathConfig && typeof pv.pathConfig === "object") {
+      checkUnknownFields(pv.pathConfig, ALLOWED_CANVAS_FIELDS.pvPathConfig, "pv.pathConfig", issues);
+    }
+    if (pv.display && typeof pv.display === "object") {
+      const display = pv.display;
+      checkUnknownFields(display, ALLOWED_CANVAS_FIELDS.pvDisplay, "pv.display", issues);
+      if (display.theme && typeof display.theme === "object") {
+        checkUnknownFields(display.theme, ALLOWED_CANVAS_FIELDS.pvDisplayTheme, "pv.display.theme", issues);
+      }
+      if (display.animations && typeof display.animations === "object") {
+        checkUnknownFields(display.animations, ALLOWED_CANVAS_FIELDS.pvDisplayAnimations, "pv.display.animations", issues);
+      }
     }
     if (pv.nodeTypes && typeof pv.nodeTypes === "object") {
       canvasNodeTypes = Object.keys(pv.nodeTypes);
+      for (const [typeId, typeDef] of Object.entries(pv.nodeTypes)) {
+        if (typeDef && typeof typeDef === "object") {
+          checkUnknownFields(typeDef, ALLOWED_CANVAS_FIELDS.pvNodeType, `pv.nodeTypes.${typeId}`, issues);
+        }
+      }
+    }
+    if (pv.edgeTypes && typeof pv.edgeTypes === "object") {
+      canvasEdgeTypes = Object.keys(pv.edgeTypes);
+      for (const [typeId, typeDef] of Object.entries(pv.edgeTypes)) {
+        if (typeDef && typeof typeDef === "object") {
+          const edgeTypeDef = typeDef;
+          checkUnknownFields(edgeTypeDef, ALLOWED_CANVAS_FIELDS.pvEdgeType, `pv.edgeTypes.${typeId}`, issues);
+          if (edgeTypeDef.animation && typeof edgeTypeDef.animation === "object") {
+            checkUnknownFields(edgeTypeDef.animation, ALLOWED_CANVAS_FIELDS.pvEdgeTypeAnimation, `pv.edgeTypes.${typeId}.animation`, issues);
+          }
+          if (edgeTypeDef.labelConfig && typeof edgeTypeDef.labelConfig === "object") {
+            checkUnknownFields(edgeTypeDef.labelConfig, ALLOWED_CANVAS_FIELDS.pvEdgeTypeLabelConfig, `pv.edgeTypes.${typeId}.labelConfig`, issues);
+          }
+        }
+      }
     }
   }
   const allDefinedNodeTypes = [.../* @__PURE__ */ new Set([...canvasNodeTypes, ...libraryNodeTypes])];
@@ -13532,25 +13708,38 @@ function validateCanvas(canvas, filePath, library) {
         return;
       }
       const n = node;
+      const nodePath2 = `nodes[${index}]`;
+      const nodeLabel = n.id || index;
+      const nodeType = n.type;
+      let allowedNodeFields = [...ALLOWED_CANVAS_FIELDS.nodeBase];
+      if (nodeType === "text") {
+        allowedNodeFields = [...allowedNodeFields, ...ALLOWED_CANVAS_FIELDS.nodeText];
+      } else if (nodeType === "file") {
+        allowedNodeFields = [...allowedNodeFields, ...ALLOWED_CANVAS_FIELDS.nodeFile];
+      } else if (nodeType === "link") {
+        allowedNodeFields = [...allowedNodeFields, ...ALLOWED_CANVAS_FIELDS.nodeLink];
+      } else if (nodeType === "group") {
+        allowedNodeFields = [...allowedNodeFields, ...ALLOWED_CANVAS_FIELDS.nodeGroup];
+      }
+      checkUnknownFields(n, allowedNodeFields, nodePath2, issues);
       if (typeof n.id !== "string" || !n.id) {
-        issues.push({ type: "error", message: `Node at index ${index} must have a string "id"`, path: `nodes[${index}].id` });
+        issues.push({ type: "error", message: `Node at index ${index} must have a string "id"`, path: `${nodePath2}.id` });
       }
       if (typeof n.type !== "string") {
-        issues.push({ type: "error", message: `Node "${n.id || index}" must have a string "type"`, path: `nodes[${index}].type` });
+        issues.push({ type: "error", message: `Node "${nodeLabel}" must have a string "type"`, path: `${nodePath2}.type` });
       }
       if (typeof n.x !== "number") {
-        issues.push({ type: "error", message: `Node "${n.id || index}" must have a numeric "x" position`, path: `nodes[${index}].x` });
+        issues.push({ type: "error", message: `Node "${nodeLabel}" must have a numeric "x" position`, path: `${nodePath2}.x` });
       }
       if (typeof n.y !== "number") {
-        issues.push({ type: "error", message: `Node "${n.id || index}" must have a numeric "y" position`, path: `nodes[${index}].y` });
+        issues.push({ type: "error", message: `Node "${nodeLabel}" must have a numeric "y" position`, path: `${nodePath2}.y` });
       }
       if (typeof n.width !== "number") {
-        issues.push({ type: "error", message: `Node "${n.id || index}" must have a numeric "width"`, path: `nodes[${index}].width` });
+        issues.push({ type: "error", message: `Node "${nodeLabel}" must have a numeric "width"`, path: `${nodePath2}.width` });
       }
       if (typeof n.height !== "number") {
-        issues.push({ type: "error", message: `Node "${n.id || index}" must have a numeric "height"`, path: `nodes[${index}].height` });
+        issues.push({ type: "error", message: `Node "${nodeLabel}" must have a numeric "height"`, path: `${nodePath2}.height` });
       }
-      const nodeType = n.type;
       const isStandardType = STANDARD_CANVAS_TYPES.includes(nodeType);
       if (!isStandardType) {
         if (!n.pv || typeof n.pv !== "object") {
@@ -13581,12 +13770,37 @@ function validateCanvas(canvas, filePath, library) {
       }
       if (n.pv && typeof n.pv === "object") {
         const nodePv = n.pv;
+        checkUnknownFields(nodePv, ALLOWED_CANVAS_FIELDS.nodePv, `${nodePath2}.pv`, issues);
+        if (nodePv.states && typeof nodePv.states === "object") {
+          for (const [stateId, stateDef] of Object.entries(nodePv.states)) {
+            if (stateDef && typeof stateDef === "object") {
+              checkUnknownFields(stateDef, ALLOWED_CANVAS_FIELDS.nodePvState, `${nodePath2}.pv.states.${stateId}`, issues);
+            }
+          }
+        }
+        if (nodePv.dataSchema && typeof nodePv.dataSchema === "object") {
+          for (const [fieldName, fieldDef] of Object.entries(nodePv.dataSchema)) {
+            if (fieldDef && typeof fieldDef === "object") {
+              checkUnknownFields(fieldDef, ALLOWED_CANVAS_FIELDS.nodePvDataSchemaField, `${nodePath2}.pv.dataSchema.${fieldName}`, issues);
+            }
+          }
+        }
+        if (nodePv.layout && typeof nodePv.layout === "object") {
+          checkUnknownFields(nodePv.layout, ALLOWED_CANVAS_FIELDS.nodePvLayout, `${nodePath2}.pv.layout`, issues);
+        }
+        if (Array.isArray(nodePv.actions)) {
+          nodePv.actions.forEach((action, actionIndex) => {
+            if (action && typeof action === "object") {
+              checkUnknownFields(action, ALLOWED_CANVAS_FIELDS.nodePvAction, `${nodePath2}.pv.actions[${actionIndex}]`, issues);
+            }
+          });
+        }
         if (typeof nodePv.nodeType === "string" && nodePv.nodeType) {
           if (allDefinedNodeTypes.length === 0) {
             issues.push({
               type: "error",
-              message: `Node "${n.id || index}" uses nodeType "${nodePv.nodeType}" but no node types are defined`,
-              path: `nodes[${index}].pv.nodeType`,
+              message: `Node "${nodeLabel}" uses nodeType "${nodePv.nodeType}" but no node types are defined`,
+              path: `${nodePath2}.pv.nodeType`,
               suggestion: "Define node types in canvas pv.nodeTypes or library.yaml nodeComponents"
             });
           } else if (!allDefinedNodeTypes.includes(nodePv.nodeType)) {
@@ -13600,8 +13814,8 @@ function validateCanvas(canvas, filePath, library) {
             const suggestion = sources.length > 0 ? `Available types from ${sources.join(" | ")}` : "Define node types in canvas pv.nodeTypes or library.yaml nodeComponents";
             issues.push({
               type: "error",
-              message: `Node "${n.id || index}" uses undefined nodeType "${nodePv.nodeType}"`,
-              path: `nodes[${index}].pv.nodeType`,
+              message: `Node "${nodeLabel}" uses undefined nodeType "${nodePv.nodeType}"`,
+              path: `${nodePath2}.pv.nodeType`,
               suggestion
             });
           }
@@ -13619,27 +13833,41 @@ function validateCanvas(canvas, filePath, library) {
         return;
       }
       const e = edge;
+      const edgePath = `edges[${index}]`;
+      const edgeLabel = e.id || index;
+      checkUnknownFields(e, ALLOWED_CANVAS_FIELDS.edge, edgePath, issues);
       if (typeof e.id !== "string" || !e.id) {
-        issues.push({ type: "error", message: `Edge at index ${index} must have a string "id"`, path: `edges[${index}].id` });
+        issues.push({ type: "error", message: `Edge at index ${index} must have a string "id"`, path: `${edgePath}.id` });
       }
       if (typeof e.fromNode !== "string") {
-        issues.push({ type: "error", message: `Edge "${e.id || index}" must have a string "fromNode"`, path: `edges[${index}].fromNode` });
+        issues.push({ type: "error", message: `Edge "${edgeLabel}" must have a string "fromNode"`, path: `${edgePath}.fromNode` });
       } else if (!nodeIds.has(e.fromNode)) {
-        issues.push({ type: "error", message: `Edge "${e.id || index}" references unknown node "${e.fromNode}"`, path: `edges[${index}].fromNode` });
+        issues.push({ type: "error", message: `Edge "${edgeLabel}" references unknown node "${e.fromNode}"`, path: `${edgePath}.fromNode` });
       }
       if (typeof e.toNode !== "string") {
-        issues.push({ type: "error", message: `Edge "${e.id || index}" must have a string "toNode"`, path: `edges[${index}].toNode` });
+        issues.push({ type: "error", message: `Edge "${edgeLabel}" must have a string "toNode"`, path: `${edgePath}.toNode` });
       } else if (!nodeIds.has(e.toNode)) {
-        issues.push({ type: "error", message: `Edge "${e.id || index}" references unknown node "${e.toNode}"`, path: `edges[${index}].toNode` });
+        issues.push({ type: "error", message: `Edge "${edgeLabel}" references unknown node "${e.toNode}"`, path: `${edgePath}.toNode` });
       }
       if (e.pv && typeof e.pv === "object") {
         const edgePv = e.pv;
+        checkUnknownFields(edgePv, ALLOWED_CANVAS_FIELDS.edgePv, `${edgePath}.pv`, issues);
+        if (edgePv.animation && typeof edgePv.animation === "object") {
+          checkUnknownFields(edgePv.animation, ALLOWED_CANVAS_FIELDS.edgePvAnimation, `${edgePath}.pv.animation`, issues);
+        }
+        if (Array.isArray(edgePv.activatedBy)) {
+          edgePv.activatedBy.forEach((trigger, triggerIndex) => {
+            if (trigger && typeof trigger === "object") {
+              checkUnknownFields(trigger, ALLOWED_CANVAS_FIELDS.edgePvActivatedBy, `${edgePath}.pv.activatedBy[${triggerIndex}]`, issues);
+            }
+          });
+        }
         if (edgePv.edgeType && typeof edgePv.edgeType === "string") {
           if (allDefinedEdgeTypes.length === 0) {
             issues.push({
               type: "error",
-              message: `Edge "${e.id || index}" uses edgeType "${edgePv.edgeType}" but no edge types are defined`,
-              path: `edges[${index}].pv.edgeType`,
+              message: `Edge "${edgeLabel}" uses edgeType "${edgePv.edgeType}" but no edge types are defined`,
+              path: `${edgePath}.pv.edgeType`,
               suggestion: "Define edge types in canvas pv.edgeTypes or library.yaml edgeComponents"
             });
           } else if (!allDefinedEdgeTypes.includes(edgePv.edgeType)) {
@@ -13653,8 +13881,8 @@ function validateCanvas(canvas, filePath, library) {
             const suggestion = sources.length > 0 ? `Available types from ${sources.join(" | ")}` : "Define edge types in canvas pv.edgeTypes or library.yaml edgeComponents";
             issues.push({
               type: "error",
-              message: `Edge "${e.id || index}" uses undefined edgeType "${edgePv.edgeType}"`,
-              path: `edges[${index}].pv.edgeType`,
+              message: `Edge "${edgeLabel}" uses undefined edgeType "${edgePv.edgeType}"`,
+              path: `${edgePath}.pv.edgeType`,
               suggestion
             });
           }
@@ -13713,21 +13941,33 @@ function createValidateCommand() {
       }
       const principalViewsDir = (0, import_node_path5.resolve)(process.cwd(), ".principal-views");
       const library = loadLibrary(principalViewsDir);
+      let libraryResult = null;
+      if (library && Object.keys(library.raw).length > 0) {
+        const libraryIssues = validateLibrary(library);
+        const libraryHasErrors = libraryIssues.some((i) => i.type === "error");
+        libraryResult = {
+          file: (0, import_node_path5.relative)(process.cwd(), library.path),
+          isValid: !libraryHasErrors,
+          issues: libraryIssues
+        };
+      }
       const results = matchedFiles.map((f) => validateFile(f, library));
-      const validCount = results.filter((r) => r.isValid).length;
-      const invalidCount = results.length - validCount;
+      const allResults = libraryResult ? [libraryResult, ...results] : results;
+      const validCount = allResults.filter((r) => r.isValid).length;
+      const invalidCount = allResults.length - validCount;
       if (options.json) {
         console.log(JSON.stringify({
-          files: results,
-          summary: { total: results.length, valid: validCount, invalid: invalidCount }
+          files: allResults,
+          summary: { total: allResults.length, valid: validCount, invalid: invalidCount }
         }, null, 2));
       } else {
         if (!options.quiet) {
+          const fileCount = libraryResult ? `${results.length} canvas file(s) + library` : `${results.length} canvas file(s)`;
           console.log(source_default.bold(`
-Validating ${results.length} canvas file(s)...
+Validating ${fileCount}...
 `));
         }
-        for (const result of results) {
+        for (const result of allResults) {
           if (result.isValid) {
             if (!options.quiet) {
               console.log(source_default.green(`\u2713 ${result.file}`));
@@ -13754,7 +13994,7 @@ Validating ${results.length} canvas file(s)...
         if (invalidCount === 0) {
           console.log(source_default.green(`\u2713 All ${validCount} file(s) are valid`));
         } else {
-          console.log(source_default.red(`\u2717 ${invalidCount} of ${results.length} file(s) failed validation`));
+          console.log(source_default.red(`\u2717 ${invalidCount} of ${allResults.length} file(s) failed validation`));
           process.exit(1);
         }
       }
@@ -14915,19 +15155,19 @@ var ConfigurationLoader = class _ConfigurationLoader {
     this.fsAdapter = fsAdapter;
   }
   /**
-   * Check if the .vgc/ configuration directory exists
+   * Check if the .principal-views/ configuration directory exists
    *
    * @param baseDir - Base directory to search from
-   * @returns True if .vgc/ directory exists
+   * @returns True if .principal-views/ directory exists
    */
   hasConfigDirectory(baseDir) {
     const configPath = this.fsAdapter.join(baseDir, _ConfigurationLoader.CONFIG_DIR);
     return this.fsAdapter.exists(configPath) && this.fsAdapter.isDirectory(configPath);
   }
   /**
-   * List all available configuration names in .vgc/ folder
+   * List all available configuration names in .principal-views/ folder
    *
-   * @param baseDir - Base directory containing .vgc/ folder
+   * @param baseDir - Base directory containing .principal-views/ folder
    * @returns Array of configuration names (without extensions)
    */
   listConfigurations(baseDir) {
@@ -14942,7 +15182,7 @@ var ConfigurationLoader = class _ConfigurationLoader {
    * Load a specific configuration by name
    *
    * @param name - Configuration name (without extension)
-   * @param baseDir - Base directory containing .vgc/ folder
+   * @param baseDir - Base directory containing .principal-views/ folder
    * @returns Configuration file or null if not found/invalid
    */
   loadByName(name, baseDir) {
@@ -14972,9 +15212,9 @@ var ConfigurationLoader = class _ConfigurationLoader {
     return null;
   }
   /**
-   * Load all configurations from .vgc/ folder
+   * Load all configurations from .principal-views/ folder
    *
-   * @param baseDir - Base directory containing .vgc/ folder
+   * @param baseDir - Base directory containing .principal-views/ folder
    * @returns Result containing all loaded configs and any errors
    */
   loadAll(baseDir) {
@@ -14984,8 +15224,8 @@ var ConfigurationLoader = class _ConfigurationLoader {
     };
     if (!this.hasConfigDirectory(baseDir)) {
       result.errors.push({
-        file: ".vgc",
-        error: "Configuration directory .vgc/ not found"
+        file: ".principal-views",
+        error: "Configuration directory .principal-views/ not found"
       });
       return result;
     }
@@ -15027,13 +15267,13 @@ var ConfigurationLoader = class _ConfigurationLoader {
    * Get the configuration directory path
    *
    * @param baseDir - Base directory
-   * @returns Full path to .vgc/ directory
+   * @returns Full path to .principal-views/ directory
    */
   getConfigDirectoryPath(baseDir) {
     return this.fsAdapter.join(baseDir, _ConfigurationLoader.CONFIG_DIR);
   }
 };
-ConfigurationLoader.CONFIG_DIR = ".vgc";
+ConfigurationLoader.CONFIG_DIR = ".principal-views";
 
 // ../core/dist/rules/types.js
 function normalizeSeverity(severity) {
@@ -15270,7 +15510,7 @@ function createRulesEngine(rules) {
 }
 
 // ../core/dist/rules/config.js
-var DEFAULT_INCLUDE_PATTERNS = [".vgc/**/*.yaml", ".vgc/**/*.yml", ".vgc/**/*.json"];
+var DEFAULT_INCLUDE_PATTERNS = [".principal-views/**/*.yaml", ".principal-views/**/*.yml", ".principal-views/**/*.json"];
 var DEFAULT_EXCLUDE_PATTERNS = ["**/node_modules/**", "**/*.test.*"];
 var VALID_SEVERITIES = [
   "off",
@@ -16189,7 +16429,7 @@ var noUnknownFields = {
 function checkFields(obj, allowedFields, path4, configPath, violations) {
   for (const field of Object.keys(obj)) {
     if (!allowedFields.includes(field)) {
-      const suggestion = findSimilarField(field, allowedFields);
+      const suggestion = findSimilarField2(field, allowedFields);
       violations.push({
         ruleId: "no-unknown-fields",
         severity: "error",
@@ -16204,7 +16444,7 @@ function checkFields(obj, allowedFields, path4, configPath, violations) {
     }
   }
 }
-function findSimilarField(field, allowedFields) {
+function findSimilarField2(field, allowedFields) {
   const fieldLower = field.toLowerCase();
   for (const allowed of allowedFields) {
     const allowedLower = allowed.toLowerCase();
@@ -16924,12 +17164,9 @@ function createDefaultRulesEngine() {
 
 // src/commands/lint.ts
 var CONFIG_FILE_NAMES2 = [
-  ".principal-viewsrc.json",
-  ".principal-viewsrc.yaml",
-  ".principal-viewsrc.yml",
-  "privu.config.json",
-  "privu.config.yaml",
-  "privu.config.yml"
+  ".privurc.yaml",
+  ".privurc.yml",
+  ".privurc.json"
 ];
 function findConfig(startDir) {
   let currentDir = (0, import_node_path11.resolve)(startDir);
@@ -17142,7 +17379,7 @@ function createLintCommand() {
       });
       const configFiles = matchedFiles.filter((f) => {
         const name = (0, import_node_path11.basename)(f).toLowerCase();
-        return !name.startsWith("library.") && !name.startsWith(".principal-viewsrc") && !name.startsWith("privu.config");
+        return !name.startsWith("library.") && !name.startsWith(".privurc");
       });
       if (configFiles.length === 0) {
         if (options.json) {