sysmledgraph 0.7.0

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Systems Library/VerificationCases.sysml

@@ -0,0 +1,103 @@
+standard library package VerificationCases {
+	doc
+	/*
+	 * This package defines the base types for verification cases and related behavioral elements 
+	 * in the SysML language.
+	 */
+
+	private import Cases::Case;
+	private import Cases::cases;
+	private import Requirements::RequirementCheck;
+	private import ScalarValues::Boolean;
+	
+	abstract verification def VerificationCase :> Case {
+		doc
+		/*
+		 * VerificationCase is the most general class of performances of VerificationCaseDefinitions. 
+		 * VericationCase is the base class of all VerificationCaseDefinitions.
+		 */
+	
+		ref verification self : VerificationCase :>> Case::self;		
+		subject subj :>> Case::subj;
+		return verdict : VerdictKind :>> result;
+		
+		objective obj :>> Case::obj {
+			subject subj = VerificationCase::subj;
+			
+			requirement requirementVerifications : RequirementCheck[0..*] :> subrequirements {
+				doc
+				/*
+				 * A record of the evaluations of the RequirementChecks of requirements being verified.
+				 */
+			}
+		}
+		
+		ref requirement requirementVerifications : RequirementCheck[0..*] = obj.requirementVerifications {
+			doc
+			/*
+			 * Checks on whether the verifiedRequirements of the VerificationCase have been satisfied.
+			 */
+		}
+		
+		abstract verification subVerificationCases : VerificationCase[0..*] :> verificationCases, subcases {
+			doc
+			/*
+			 * The subcases of this VerificationCase that are VerificationCaseUsages.
+			 */
+		}
+		
+	}
+	
+	abstract verification verificationCases : VerificationCase[0..*] nonunique  :> cases {
+		doc
+		/*
+		 * verificationCases is the base feature of all VerificationCaseUsages.
+		 */
+	}
+	
+	enum def VerdictKind {
+		doc
+		/*
+		 * VerdictKind is an enumeration of the possible results of a VerificationCase.
+		 */
+	
+		pass;
+		fail;
+		inconclusive;
+		error;
+	}
+	
+	calc def PassIf {
+		doc
+		/*
+		 * PassIf returns a pass or fail VerdictKind depending on whether its argument is
+		 * true or false.
+		 */
+	
+		in attribute isPassing : Boolean;
+		return attribute verdict : VerdictKind = if isPassing? VerdictKind::pass else VerdictKind::fail;
+	}
+	
+	metadata def VerificationMethod {
+		doc
+		/*
+		 * VerificationMethod can be used as metadata annotating a verification case or action.
+		 */
+	
+		attribute kind : VerificationMethodKind[1..*];
+	}
+	
+	enum def VerificationMethodKind {
+		doc
+		/*
+		 * VerificationMethodKind is an enumeration of the standard methods by which verification
+		 * can be carried out.
+		 */
+	
+		inspect;
+		analyze;
+		demo;
+		test;
+	}
+	
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Systems Library/Views.sysml

@@ -0,0 +1,164 @@
+standard library package Views {
+	doc
+	/*
+	 * This package defines the base types for views, viewpoints, renderings and related elements 
+	 * in the SysML language.
+	 */
+
+	private import Parts::Part;
+	private import Parts::parts;
+	private import Requirements::RequirementCheck;
+	private import Requirements::requirementChecks;
+	
+	abstract view def View :> Part {
+		ref view :>> self : View;
+		
+		abstract ref view subviews : View[0..*] :> views {
+    		doc
+    		/*
+    		 * Other Views that are used in the rendering of this View.
+    		 */
+		}
+		
+		abstract ref rendering viewRendering : Rendering[0..1] {
+            doc
+			/*
+			 * The rendering of this View.
+			 */
+		}
+		
+		viewpoint viewpointSatisfactions : ViewpointCheck[0..*] :> viewpointChecks, checkedConstraints {
+            doc
+			/*
+			 * Checks that the View satisfies all required ViewpointUsages.
+			 */
+		}
+		
+		satisfy requirement viewpointConformance by that {
+			doc
+			/*
+			 * An assertion that all viewpointSatisfactions are true.
+			 */
+			 
+			require viewpointSatisfactions {
+				doc
+				/*
+				 * The required ViewpointChecks.
+				 */
+                ref :>> ownedPerformances::this, subperformances::this default that.that;
+			}
+		}
+	}
+	
+	abstract viewpoint def ViewpointCheck :> RequirementCheck {
+		doc
+		/*
+		 * ViewpointCheck is a RequirementCheck for checking if a View meets the concerns of viewpoint stakeholders. 
+		 * It is the base type of all ViewpointDefinitions.
+		 */
+	
+		ref viewpoint :>> self : ViewpointCheck;		
+		subject subj : View[1] :>> RequirementCheck::subj;
+	}
+	
+	abstract rendering def Rendering :> Part {
+		doc
+		/*
+		 * Rendering is the base type of all RenderingDefinitions.
+		 */
+	
+		ref rendering :>> self : Rendering;
+		
+		abstract ref rendering subrenderings : Rendering[0..*] :> renderings {
+			doc
+			/*
+			 * Other Renderings used to carry out this Rendering.
+			 */
+		}
+	}
+	
+	rendering def TextualRendering :> Rendering {
+		doc
+		/*
+		 * A TextualRendering is a Rendering of a View into a textual format.
+		 */
+	}
+
+	rendering def GraphicalRendering :> Rendering {
+		doc
+		/*
+		 * A GraphicalRendering is a Rendering of a View into a Graphical format.
+		 */
+	}
+
+	rendering def TabularRendering :> Rendering {
+		doc
+		/*
+		 * A TabularRendering is a Rendering of a View into a tabular format.
+		 */
+	}
+	
+	abstract view views : View[0..*] nonunique :> parts {
+		doc
+		/*
+		 * views is the base feature of all ViewUsages.
+		 */
+	}
+	
+	abstract viewpoint viewpointChecks : ViewpointCheck[0..*] nonunique :> requirementChecks {
+		doc
+		/*
+		 * viewpointChecks is the base feature of all ViewpointUsages.
+		 */
+	}
+	
+	abstract rendering renderings : Rendering[0..*] nonunique :> parts {
+		doc
+		/*
+		 * renderings is the base feature of all RenderingUsages.
+		 */
+	}
+	
+	rendering asTextualNotation : TextualRendering[1] :> renderings {
+		doc
+		/*
+		 * asTextualNotation renders a View into textual notation as defined in the 
+		 * KerML and SysML specifications.
+		 */
+	}
+	
+	rendering asTreeDiagram : GraphicalRendering[1] :> renderings {
+		doc
+		/*
+		 * asTreeDiagram renders a View as a tree diagram, using the 
+		 * graphical notation defined in the SysML specification.
+		 */
+	}
+	
+	rendering asInterconnectionDiagram : GraphicalRendering[1] :> renderings {
+		doc
+		/*
+		 * asInterconnectionDiagram renders a View as an interconnection 
+		 * diagram, using the graphical notation defined in the SysML specification.
+		 */
+	}
+	
+	rendering asElementTable : TabularRendering[1] :> renderings {
+		doc
+		/*
+		 * asElementTable  renders a View as a table, with one row for each exposed 
+		 * Element and columns rendered by applying the columnViews in order to the
+		 * Element in each row.
+		 */
+	
+		view columnView[0..*] ordered {
+			doc
+			/*
+			 * The Views to be rendered in the column cells, in order, of each rows of the table.
+			 */
+		
+			abstract ref rendering :>> viewRendering[0..1];
+		}
+		rendering :>> subrenderings[0..*] = columnView.viewRendering;
+	}
+}

package/lsp/package-lock.json

@@ -0,0 +1,30 @@
+{
+  "name": "sysmledgraph-lsp-server",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "sysmledgraph-lsp-server",
+      "version": "1.0.0",
+      "hasInstallScript": true,
+      "dependencies": {
+        "sysml-v2-lsp": "^0.7.0"
+      }
+    },
+    "node_modules/sysml-v2-lsp": {
+      "version": "0.7.0",
+      "resolved": "https://registry.npmjs.org/sysml-v2-lsp/-/sysml-v2-lsp-0.7.0.tgz",
+      "integrity": "sha512-cJ2JINpe7Ez1gyMO020gEokoTLmqRFv+KTcNqGq+10PI3mE0q74anHLxFzbrjIx2wRDeoacQcMg3v9XVkvuWHw==",
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "sysml-mcp": "dist/server/mcpServer.js"
+      },
+      "engines": {
+        "node": ">=20",
+        "vscode": "^1.85.0"
+      }
+    }
+  }
+}

package/lsp/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "sysmledgraph-lsp-server",
+  "version": "1.0.0",
+  "private": true,
+  "description": "Dedicated LSP server setup for SysML (sysml-v2-lsp). Run from here so the server has its own cwd and init.",
+  "type": "module",
+  "scripts": {
+    "start": "node node_modules/sysml-v2-lsp/dist/server/server.js",
+    "mcp": "node node_modules/sysml-v2-lsp/dist/server/mcpServer.js",
+    "postinstall": "node -e \"console.log('LSP server deps ready. Run: npm start (stdio) or use path in SYSMLLSP_SERVER_PATH')\""
+  },
+  "dependencies": {
+    "sysml-v2-lsp": "^0.7.0"
+  }
+}

package/lsp/test-server.mjs

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+/**
+ * Minimal test: spawn the LSP server in this folder and send initialize + documentSymbol.
+ * Run from lsp/: node test-server.mjs
+ */
+import { spawn } from 'child_process';
+import { resolve } from 'path';
+import { pathToFileURL } from 'url';
+
+const serverPath = resolve(process.cwd(), 'node_modules/sysml-v2-lsp/dist/server/server.js');
+const cwd = process.cwd();
+
+function send(proc, body) {
+  const buf = Buffer.from(body, 'utf8');
+  proc.stdin?.write(`Content-Length: ${buf.length}\r\n\r\n`, 'utf8');
+  proc.stdin?.write(buf, 'utf8');
+}
+
+function createReader(proc) {
+  let buffer = '';
+  let contentLength = null;
+  let pending = null;
+  proc.stdout?.setEncoding('utf8');
+  proc.stdout?.on('data', (chunk) => {
+    buffer += chunk;
+    for (;;) {
+      if (contentLength === null) {
+        const idx = buffer.indexOf('\r\n\r\n');
+        if (idx === -1) break;
+        const m = buffer.slice(0, idx).match(/Content-Length:\s*(\d+)/i);
+        contentLength = m ? parseInt(m[1], 10) : 0;
+        buffer = buffer.slice(idx + 4);
+      }
+      if (contentLength !== null && buffer.length >= contentLength) {
+        const body = buffer.slice(0, contentLength);
+        buffer = buffer.slice(contentLength);
+        contentLength = null;
+        if (pending) {
+          pending.resolve(body);
+          pending = null;
+        }
+      } else break;
+    }
+  });
+  return () => new Promise((res, rej) => { pending = { resolve: res, reject: rej }; });
+}
+
+async function request(proc, readNext, method, params, id) {
+  send(proc, JSON.stringify({ jsonrpc: '2.0', id, method, params }));
+  for (;;) {
+    const raw = await readNext();
+    const msg = JSON.parse(raw);
+    if (msg.id === id) {
+      if (msg.error) throw new Error(msg.error.message);
+      return msg.result;
+    }
+  }
+}
+
+function notify(proc, method, params) {
+  send(proc, JSON.stringify({ jsonrpc: '2.0', method, params }));
+}
+
+const sample = `package Sample {
+  part def Foo {
+    doc /* test */
+  }
+}`;
+
+console.log('Spawning server:', serverPath);
+console.log('cwd:', cwd);
+
+const proc = spawn(process.execPath, [serverPath, '--stdio'], {
+  cwd,
+  stdio: ['pipe', 'pipe', 'pipe'],
+});
+
+proc.stderr?.on('data', () => {}); // server logs to stderr; ignore for quiet run
+
+const readNext = createReader(proc);
+
+async function run() {
+  try {
+    const rootUri = pathToFileURL(resolve(cwd, '.')).href;
+    const init = await request(proc, readNext, 'initialize', {
+      processId: process.pid,
+      rootUri,
+      capabilities: { textDocument: { documentSymbol: { hierarchicalDocumentSymbolSupport: true } } },
+      workspaceFolders: [{ uri: rootUri, name: 'workspace' }],
+    }, 1);
+    console.log('Initialize result:', JSON.stringify(init, null, 2).slice(0, 500) + '...');
+
+    notify(proc, 'initialized', {});
+    await new Promise((r) => setTimeout(r, 300));
+
+    const uri = pathToFileURL(resolve(cwd, 'sample.sysml')).href;
+    notify(proc, 'textDocument/didOpen', {
+      textDocument: { uri, languageId: 'sysml', version: 1, text: sample },
+    });
+    await new Promise((r) => setTimeout(r, 500));
+
+    const symbols = await request(proc, readNext, 'textDocument/documentSymbol', { textDocument: { uri } }, 2);
+    console.log('documentSymbol count:', Array.isArray(symbols) ? symbols.length : (symbols ? 1 : 0));
+    if (Array.isArray(symbols) && symbols.length > 0) {
+      console.log('First symbol:', JSON.stringify(symbols[0], null, 2));
+    } else {
+      console.log('documentSymbol result:', JSON.stringify(symbols).slice(0, 300));
+    }
+    console.log('OK — server responded.');
+  } catch (e) {
+    throw e;
+  }
+}
+
+run().catch((e) => {
+  console.error('Error:', e.message);
+  process.exitCode = 1;
+}).finally(() => {
+  proc.kill('SIGTERM');
+});

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "sysmledgraph",
+  "version": "0.7.0",
+  "description": "Path-only SysML indexer: knowledge graph (Kuzu), MCP server (query, context, impact, rename, cypher), CLI (analyze, list, clean)",
+  "type": "module",
+  "main": "dist/src/index.js",
+  "bin": {
+    "sysmledgraph": "dist/bin/cli.js",
+    "sysmledgraph-mcp": "dist/mcp/index.js"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "commander": "^12.0.0",
+    "fast-glob": "^3.3.2",
+    "kuzu": "^0.11.3",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "sysml-v2-lsp": "^0.7.0",
+    "typescript": "^5.3.0",
+    "vitest": "^1.2.0"
+  },
+  "keywords": [
+    "sysml",
+    "knowledge-graph",
+    "mcp",
+    "kuzu",
+    "indexer"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chouswei/codebase-sysmledgraph.git"
+  },
+  "files": [
+    "dist",
+    "scripts",
+    "lsp",
+    "README.md",
+    "docs"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "clean": "node scripts/clean.mjs",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "analyze": "node dist/bin/cli.js analyze",
+    "export-graph": "node scripts/export-graph.mjs",
+    "generate-map": "node scripts/generate-map.mjs",
+    "index-and-map": "node scripts/index-and-map.mjs",
+    "deploy-skills": "node scripts/deploy-skills.mjs",
+    "mcp": "node dist/mcp/index.js",
+    "check:sysml-lsp": "node scripts/check-sysml-v2-lsp-version.mjs",
+    "setup-lsp": "node scripts/setup-lsp.mjs",
+    "prepublishOnly": "npm run build"
+  }
+}

package/scripts/access-sysml-mcp.mjs

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+/**
+ * Access sysml-v2-lsp MCP server from code (Content-Length client).
+ * Run from repo root after: npm run build
+ *
+ *   node scripts/access-sysml-mcp.mjs
+ *   node scripts/access-sysml-mcp.mjs --debug   # log stdout/stderr
+ *
+ * See docs/MCP_INTERACTION_GUIDE.md for lifecycle and framing.
+ */
+import { createSysmlMcpClient } from '../dist/src/parser/sysml-mcp-client.js';
+
+const debug = process.argv.includes('--debug');
+const code = `package TestPkg {
+  requirement ReqOne {
+    doc /* req */ "Requirement one.";
+  }
+}`;
+const uri = 'file:///access-test.sysml';
+
+async function main() {
+  const client = await createSysmlMcpClient({
+    initTimeout: 30000,
+    debug,
+  });
+  try {
+    const parseResult = await client.parse(code, uri);
+    console.log('parse:', JSON.stringify(parseResult, null, 2));
+
+    const validateResult = await client.validate(code, uri);
+    console.log('validate:', JSON.stringify(validateResult, null, 2));
+
+    const symbolsResult = await client.getSymbols(code, uri);
+    console.log('getSymbols count:', symbolsResult?.count ?? symbolsResult);
+
+    console.log('\nOK — sysml-v2-lsp MCP accessed from code.');
+  } finally {
+    client.close();
+  }
+}
+
+main().catch((err) => {
+  console.error('Error:', err.message);
+  process.exit(1);
+});

package/scripts/check-sysml-v2-lsp-version.mjs

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+/**
+ * Check installed sysml-v2-lsp version and MCP server path.
+ * Run from repo root: node scripts/check-sysml-v2-lsp-version.mjs
+ */
+import { readFileSync, existsSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const pkgPath = resolve(root, 'package.json');
+const mcpPath = resolve(root, 'node_modules/sysml-v2-lsp/dist/server/mcpServer.js');
+
+let version = null;
+try {
+  const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+  const dep = pkg.devDependencies?.['sysml-v2-lsp'] ?? pkg.dependencies?.['sysml-v2-lsp'];
+  if (dep) version = dep;
+} catch (e) {
+  console.error('Could not read package.json:', e.message);
+  process.exit(1);
+}
+
+const mcpExists = existsSync(mcpPath);
+
+console.log('sysml-v2-lsp:');
+console.log('  version (package.json):', version ?? '(not in dependencies)');
+console.log('  MCP server path exists:', mcpExists ? 'yes' : 'no');
+console.log('  path:', mcpPath);
+
+if (!version) {
+  console.error('\nAdd "sysml-v2-lsp" to devDependencies in package.json.');
+  process.exit(1);
+}
+if (!mcpExists) {
+  console.error('\nRun: npm install');
+  process.exit(1);
+}
+console.log('\nOK — sysml-v2-lsp is installed and MCP server path is present.');

package/scripts/clean.mjs

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+/** Remove build/output artifacts (dist/, etc.). */
+import { rmSync, existsSync } from 'fs';
+import { join } from 'path';
+import { cwd } from 'process';
+
+const dirs = ['dist'];
+for (const d of dirs) {
+  const full = join(cwd(), d);
+  if (existsSync(full)) {
+    rmSync(full, { recursive: true });
+    console.log('Removed', full);
+  }
+}

package/scripts/compare-mcp-vs-lsp-symbols.mjs

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+/**
+ * Compare MCP getSymbols vs LSP documentSymbol for the same file.
+ * Writes results to compare-mcp-symbols.json and compare-lsp-symbols.json.
+ * Run from repo root after build: node scripts/compare-mcp-vs-lsp-symbols.mjs [file]
+ */
+import { readFile, writeFile } from 'fs/promises';
+import { resolve } from 'path';
+import { existsSync } from 'fs';
+
+const pathArg = process.argv[2] || 'test/fixtures/sysml/sample.sysml';
+const absPath = resolve(process.cwd(), pathArg);
+if (!existsSync(absPath)) {
+  console.error('File not found:', absPath);
+  process.exit(1);
+}
+
+if (!process.env.SYSMLLSP_SERVER_PATH) {
+  const lspPath = resolve(process.cwd(), 'lsp/node_modules/sysml-v2-lsp/dist/server/server.js');
+  const rootPath = resolve(process.cwd(), 'node_modules/sysml-v2-lsp/dist/server/server.js');
+  if (existsSync(lspPath)) process.env.SYSMLLSP_SERVER_PATH = lspPath;
+  else if (existsSync(rootPath)) process.env.SYSMLLSP_SERVER_PATH = rootPath;
+}
+
+const content = await readFile(absPath, 'utf-8');
+const uri = `file:///${absPath.replace(/\\/g, '/')}`;
+
+const out = { file: absPath, uri, contentLength: content.length, mcp: null, lsp: null, error: null };
+
+// 1) MCP getSymbols
+console.log('Calling MCP getSymbols...');
+try {
+  const { createSysmlMcpClient, getMcpServerPath } = await import('../dist/src/parser/sysml-mcp-client.js');
+  const serverPath = getMcpServerPath();
+  if (serverPath) {
+    const client = await createSysmlMcpClient({ serverPath, initTimeout: 60000 });
+    try {
+      const result = await client.getSymbols(content, uri);
+      out.mcp = { count: result?.count ?? 0, symbols: result?.symbols ?? [], raw: result };
+      console.log('MCP symbols count:', out.mcp.count);
+    } finally {
+      client.close();
+    }
+  } else {
+    out.mcp = { error: 'getMcpServerPath() returned null' };
+  }
+} catch (e) {
+  out.mcp = { error: String(e.message ?? e) };
+  console.log('MCP error:', out.mcp.error);
+}
+
+// 2) LSP documentSymbol (raw request/response)
+console.log('Calling LSP documentSymbol...');
+try {
+  const { getDocumentSymbolsFromLsp, closeLspClient } = await import('../dist/src/parser/lsp-client.js');
+  const raw = await Promise.race([
+    getDocumentSymbolsFromLsp(absPath, content),
+    new Promise((_, rej) => setTimeout(() => rej(new Error('LSP timeout 25s')), 25000)),
+  ]);
+  closeLspClient();
+  const arr = Array.isArray(raw) ? raw : (raw != null ? [raw] : []);
+  out.lsp = { count: arr.length, symbols: arr, rawType: raw === null ? 'null' : Array.isArray(raw) ? 'array' : typeof raw };
+  console.log('LSP symbols count:', out.lsp.count);
+  if (arr.length > 0 && arr[0]) {
+    console.log('LSP first symbol keys:', Object.keys(arr[0]));
+    console.log('LSP first detail:', arr[0].detail, 'kind:', arr[0].kind);
+  }
+} catch (e) {
+  out.lsp = { error: String(e.message ?? e) };
+  console.log('LSP error:', out.lsp.error);
+}
+
+await writeFile('compare-mcp-symbols.json', JSON.stringify(out.mcp, null, 2), 'utf-8');
+await writeFile('compare-lsp-symbols.json', JSON.stringify(out.lsp, null, 2), 'utf-8');
+console.log('\nWrote compare-mcp-symbols.json and compare-lsp-symbols.json');
+console.log('Summary: MCP count =', out.mcp?.count ?? out.mcp?.error, ', LSP count =', out.lsp?.count ?? out.lsp?.error);

package/scripts/debug-index.mjs

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+/**
+ * Debug: run discovery + load order for a path and print counts.
+ * Usage: node scripts/debug-index.mjs "c:\Projects\SystemDesign\sysml-v2-models\projects\sysmledgraph"
+ */
+import { findSysmlFiles } from '../dist/src/discovery/find-sysml.js';
+import { applyLoadOrder } from '../dist/src/discovery/load-order.js';
+
+const root = process.argv[2] || process.cwd();
+const roots = [root];
+
+const allFiles = await findSysmlFiles({ roots, includeKerml: true });
+console.log('allFiles.length', allFiles.length);
+if (allFiles.length > 0) console.log('first', allFiles[0]);
+
+const norm = (p) => p.replace(/\\/g, '/').toLowerCase();
+const rootNorm = norm(root);
+const underRoot = allFiles.filter((f) => norm(f).startsWith(rootNorm));
+console.log('underRoot.length', underRoot.length);
+
+const ordered = await applyLoadOrder(root, underRoot);
+console.log('ordered.length', ordered.length);
+if (ordered.length > 0) console.log('first ordered', ordered[0]);