topodraft-cli 0.1.0

package/dist/cli.js

@@ -0,0 +1,1692 @@
+#!/usr/bin/env node
+"use strict";
+
+// src/cli.ts
+var import_node_fs = require("node:fs");
+
+// ../../node_modules/jsonc-parser/lib/esm/impl/scanner.js
+function createScanner(text, ignoreTrivia = false) {
+  const len = text.length;
+  let pos = 0, value = "", tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
+  function scanHexDigits(count, exact) {
+    let digits = 0;
+    let value2 = 0;
+    while (digits < count || !exact) {
+      let ch = text.charCodeAt(pos);
+      if (ch >= 48 && ch <= 57) {
+        value2 = value2 * 16 + ch - 48;
+      } else if (ch >= 65 && ch <= 70) {
+        value2 = value2 * 16 + ch - 65 + 10;
+      } else if (ch >= 97 && ch <= 102) {
+        value2 = value2 * 16 + ch - 97 + 10;
+      } else {
+        break;
+      }
+      pos++;
+      digits++;
+    }
+    if (digits < count) {
+      value2 = -1;
+    }
+    return value2;
+  }
+  function setPosition(newPosition) {
+    pos = newPosition;
+    value = "";
+    tokenOffset = 0;
+    token = 16;
+    scanError = 0;
+  }
+  function scanNumber() {
+    let start = pos;
+    if (text.charCodeAt(pos) === 48) {
+      pos++;
+    } else {
+      pos++;
+      while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+      }
+    }
+    if (pos < text.length && text.charCodeAt(pos) === 46) {
+      pos++;
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+      } else {
+        scanError = 3;
+        return text.substring(start, pos);
+      }
+    }
+    let end = pos;
+    if (pos < text.length && (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101)) {
+      pos++;
+      if (pos < text.length && text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) {
+        pos++;
+      }
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+        end = pos;
+      } else {
+        scanError = 3;
+      }
+    }
+    return text.substring(start, end);
+  }
+  function scanString() {
+    let result = "", start = pos;
+    while (true) {
+      if (pos >= len) {
+        result += text.substring(start, pos);
+        scanError = 2;
+        break;
+      }
+      const ch = text.charCodeAt(pos);
+      if (ch === 34) {
+        result += text.substring(start, pos);
+        pos++;
+        break;
+      }
+      if (ch === 92) {
+        result += text.substring(start, pos);
+        pos++;
+        if (pos >= len) {
+          scanError = 2;
+          break;
+        }
+        const ch2 = text.charCodeAt(pos++);
+        switch (ch2) {
+          case 34:
+            result += '"';
+            break;
+          case 92:
+            result += "\\";
+            break;
+          case 47:
+            result += "/";
+            break;
+          case 98:
+            result += "\b";
+            break;
+          case 102:
+            result += "\f";
+            break;
+          case 110:
+            result += "\n";
+            break;
+          case 114:
+            result += "\r";
+            break;
+          case 116:
+            result += "	";
+            break;
+          case 117:
+            const ch3 = scanHexDigits(4, true);
+            if (ch3 >= 0) {
+              result += String.fromCharCode(ch3);
+            } else {
+              scanError = 4;
+            }
+            break;
+          default:
+            scanError = 5;
+        }
+        start = pos;
+        continue;
+      }
+      if (ch >= 0 && ch <= 31) {
+        if (isLineBreak(ch)) {
+          result += text.substring(start, pos);
+          scanError = 2;
+          break;
+        } else {
+          scanError = 6;
+        }
+      }
+      pos++;
+    }
+    return result;
+  }
+  function scanNext() {
+    value = "";
+    scanError = 0;
+    tokenOffset = pos;
+    lineStartOffset = lineNumber;
+    prevTokenLineStartOffset = tokenLineStartOffset;
+    if (pos >= len) {
+      tokenOffset = len;
+      return token = 17;
+    }
+    let code = text.charCodeAt(pos);
+    if (isWhiteSpace(code)) {
+      do {
+        pos++;
+        value += String.fromCharCode(code);
+        code = text.charCodeAt(pos);
+      } while (isWhiteSpace(code));
+      return token = 15;
+    }
+    if (isLineBreak(code)) {
+      pos++;
+      value += String.fromCharCode(code);
+      if (code === 13 && text.charCodeAt(pos) === 10) {
+        pos++;
+        value += "\n";
+      }
+      lineNumber++;
+      tokenLineStartOffset = pos;
+      return token = 14;
+    }
+    switch (code) {
+      // tokens: []{}:,
+      case 123:
+        pos++;
+        return token = 1;
+      case 125:
+        pos++;
+        return token = 2;
+      case 91:
+        pos++;
+        return token = 3;
+      case 93:
+        pos++;
+        return token = 4;
+      case 58:
+        pos++;
+        return token = 6;
+      case 44:
+        pos++;
+        return token = 5;
+      // strings
+      case 34:
+        pos++;
+        value = scanString();
+        return token = 10;
+      // comments
+      case 47:
+        const start = pos - 1;
+        if (text.charCodeAt(pos + 1) === 47) {
+          pos += 2;
+          while (pos < len) {
+            if (isLineBreak(text.charCodeAt(pos))) {
+              break;
+            }
+            pos++;
+          }
+          value = text.substring(start, pos);
+          return token = 12;
+        }
+        if (text.charCodeAt(pos + 1) === 42) {
+          pos += 2;
+          const safeLength = len - 1;
+          let commentClosed = false;
+          while (pos < safeLength) {
+            const ch = text.charCodeAt(pos);
+            if (ch === 42 && text.charCodeAt(pos + 1) === 47) {
+              pos += 2;
+              commentClosed = true;
+              break;
+            }
+            pos++;
+            if (isLineBreak(ch)) {
+              if (ch === 13 && text.charCodeAt(pos) === 10) {
+                pos++;
+              }
+              lineNumber++;
+              tokenLineStartOffset = pos;
+            }
+          }
+          if (!commentClosed) {
+            pos++;
+            scanError = 1;
+          }
+          value = text.substring(start, pos);
+          return token = 13;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+      // numbers
+      case 45:
+        value += String.fromCharCode(code);
+        pos++;
+        if (pos === len || !isDigit(text.charCodeAt(pos))) {
+          return token = 16;
+        }
+      // found a minus, followed by a number so
+      // we fall through to proceed with scanning
+      // numbers
+      case 48:
+      case 49:
+      case 50:
+      case 51:
+      case 52:
+      case 53:
+      case 54:
+      case 55:
+      case 56:
+      case 57:
+        value += scanNumber();
+        return token = 11;
+      // literals and unknown symbols
+      default:
+        while (pos < len && isUnknownContentCharacter(code)) {
+          pos++;
+          code = text.charCodeAt(pos);
+        }
+        if (tokenOffset !== pos) {
+          value = text.substring(tokenOffset, pos);
+          switch (value) {
+            case "true":
+              return token = 8;
+            case "false":
+              return token = 9;
+            case "null":
+              return token = 7;
+          }
+          return token = 16;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+    }
+  }
+  function isUnknownContentCharacter(code) {
+    if (isWhiteSpace(code) || isLineBreak(code)) {
+      return false;
+    }
+    switch (code) {
+      case 125:
+      case 93:
+      case 123:
+      case 91:
+      case 34:
+      case 58:
+      case 44:
+      case 47:
+        return false;
+    }
+    return true;
+  }
+  function scanNextNonTrivia() {
+    let result;
+    do {
+      result = scanNext();
+    } while (result >= 12 && result <= 15);
+    return result;
+  }
+  return {
+    setPosition,
+    getPosition: () => pos,
+    scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
+    getToken: () => token,
+    getTokenValue: () => value,
+    getTokenOffset: () => tokenOffset,
+    getTokenLength: () => pos - tokenOffset,
+    getTokenStartLine: () => lineStartOffset,
+    getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
+    getTokenError: () => scanError
+  };
+}
+function isWhiteSpace(ch) {
+  return ch === 32 || ch === 9;
+}
+function isLineBreak(ch) {
+  return ch === 10 || ch === 13;
+}
+function isDigit(ch) {
+  return ch >= 48 && ch <= 57;
+}
+var CharacterCodes;
+(function(CharacterCodes2) {
+  CharacterCodes2[CharacterCodes2["lineFeed"] = 10] = "lineFeed";
+  CharacterCodes2[CharacterCodes2["carriageReturn"] = 13] = "carriageReturn";
+  CharacterCodes2[CharacterCodes2["space"] = 32] = "space";
+  CharacterCodes2[CharacterCodes2["_0"] = 48] = "_0";
+  CharacterCodes2[CharacterCodes2["_1"] = 49] = "_1";
+  CharacterCodes2[CharacterCodes2["_2"] = 50] = "_2";
+  CharacterCodes2[CharacterCodes2["_3"] = 51] = "_3";
+  CharacterCodes2[CharacterCodes2["_4"] = 52] = "_4";
+  CharacterCodes2[CharacterCodes2["_5"] = 53] = "_5";
+  CharacterCodes2[CharacterCodes2["_6"] = 54] = "_6";
+  CharacterCodes2[CharacterCodes2["_7"] = 55] = "_7";
+  CharacterCodes2[CharacterCodes2["_8"] = 56] = "_8";
+  CharacterCodes2[CharacterCodes2["_9"] = 57] = "_9";
+  CharacterCodes2[CharacterCodes2["a"] = 97] = "a";
+  CharacterCodes2[CharacterCodes2["b"] = 98] = "b";
+  CharacterCodes2[CharacterCodes2["c"] = 99] = "c";
+  CharacterCodes2[CharacterCodes2["d"] = 100] = "d";
+  CharacterCodes2[CharacterCodes2["e"] = 101] = "e";
+  CharacterCodes2[CharacterCodes2["f"] = 102] = "f";
+  CharacterCodes2[CharacterCodes2["g"] = 103] = "g";
+  CharacterCodes2[CharacterCodes2["h"] = 104] = "h";
+  CharacterCodes2[CharacterCodes2["i"] = 105] = "i";
+  CharacterCodes2[CharacterCodes2["j"] = 106] = "j";
+  CharacterCodes2[CharacterCodes2["k"] = 107] = "k";
+  CharacterCodes2[CharacterCodes2["l"] = 108] = "l";
+  CharacterCodes2[CharacterCodes2["m"] = 109] = "m";
+  CharacterCodes2[CharacterCodes2["n"] = 110] = "n";
+  CharacterCodes2[CharacterCodes2["o"] = 111] = "o";
+  CharacterCodes2[CharacterCodes2["p"] = 112] = "p";
+  CharacterCodes2[CharacterCodes2["q"] = 113] = "q";
+  CharacterCodes2[CharacterCodes2["r"] = 114] = "r";
+  CharacterCodes2[CharacterCodes2["s"] = 115] = "s";
+  CharacterCodes2[CharacterCodes2["t"] = 116] = "t";
+  CharacterCodes2[CharacterCodes2["u"] = 117] = "u";
+  CharacterCodes2[CharacterCodes2["v"] = 118] = "v";
+  CharacterCodes2[CharacterCodes2["w"] = 119] = "w";
+  CharacterCodes2[CharacterCodes2["x"] = 120] = "x";
+  CharacterCodes2[CharacterCodes2["y"] = 121] = "y";
+  CharacterCodes2[CharacterCodes2["z"] = 122] = "z";
+  CharacterCodes2[CharacterCodes2["A"] = 65] = "A";
+  CharacterCodes2[CharacterCodes2["B"] = 66] = "B";
+  CharacterCodes2[CharacterCodes2["C"] = 67] = "C";
+  CharacterCodes2[CharacterCodes2["D"] = 68] = "D";
+  CharacterCodes2[CharacterCodes2["E"] = 69] = "E";
+  CharacterCodes2[CharacterCodes2["F"] = 70] = "F";
+  CharacterCodes2[CharacterCodes2["G"] = 71] = "G";
+  CharacterCodes2[CharacterCodes2["H"] = 72] = "H";
+  CharacterCodes2[CharacterCodes2["I"] = 73] = "I";
+  CharacterCodes2[CharacterCodes2["J"] = 74] = "J";
+  CharacterCodes2[CharacterCodes2["K"] = 75] = "K";
+  CharacterCodes2[CharacterCodes2["L"] = 76] = "L";
+  CharacterCodes2[CharacterCodes2["M"] = 77] = "M";
+  CharacterCodes2[CharacterCodes2["N"] = 78] = "N";
+  CharacterCodes2[CharacterCodes2["O"] = 79] = "O";
+  CharacterCodes2[CharacterCodes2["P"] = 80] = "P";
+  CharacterCodes2[CharacterCodes2["Q"] = 81] = "Q";
+  CharacterCodes2[CharacterCodes2["R"] = 82] = "R";
+  CharacterCodes2[CharacterCodes2["S"] = 83] = "S";
+  CharacterCodes2[CharacterCodes2["T"] = 84] = "T";
+  CharacterCodes2[CharacterCodes2["U"] = 85] = "U";
+  CharacterCodes2[CharacterCodes2["V"] = 86] = "V";
+  CharacterCodes2[CharacterCodes2["W"] = 87] = "W";
+  CharacterCodes2[CharacterCodes2["X"] = 88] = "X";
+  CharacterCodes2[CharacterCodes2["Y"] = 89] = "Y";
+  CharacterCodes2[CharacterCodes2["Z"] = 90] = "Z";
+  CharacterCodes2[CharacterCodes2["asterisk"] = 42] = "asterisk";
+  CharacterCodes2[CharacterCodes2["backslash"] = 92] = "backslash";
+  CharacterCodes2[CharacterCodes2["closeBrace"] = 125] = "closeBrace";
+  CharacterCodes2[CharacterCodes2["closeBracket"] = 93] = "closeBracket";
+  CharacterCodes2[CharacterCodes2["colon"] = 58] = "colon";
+  CharacterCodes2[CharacterCodes2["comma"] = 44] = "comma";
+  CharacterCodes2[CharacterCodes2["dot"] = 46] = "dot";
+  CharacterCodes2[CharacterCodes2["doubleQuote"] = 34] = "doubleQuote";
+  CharacterCodes2[CharacterCodes2["minus"] = 45] = "minus";
+  CharacterCodes2[CharacterCodes2["openBrace"] = 123] = "openBrace";
+  CharacterCodes2[CharacterCodes2["openBracket"] = 91] = "openBracket";
+  CharacterCodes2[CharacterCodes2["plus"] = 43] = "plus";
+  CharacterCodes2[CharacterCodes2["slash"] = 47] = "slash";
+  CharacterCodes2[CharacterCodes2["formFeed"] = 12] = "formFeed";
+  CharacterCodes2[CharacterCodes2["tab"] = 9] = "tab";
+})(CharacterCodes || (CharacterCodes = {}));
+
+// ../../node_modules/jsonc-parser/lib/esm/impl/string-intern.js
+var cachedSpaces = new Array(20).fill(0).map((_, index) => {
+  return " ".repeat(index);
+});
+var maxCachedValues = 200;
+var cachedBreakLinesWithSpaces = {
+  " ": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\n" + " ".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + " ".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r\n" + " ".repeat(index);
+    })
+  },
+  "	": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\n" + "	".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + "	".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r\n" + "	".repeat(index);
+    })
+  }
+};
+
+// ../../node_modules/jsonc-parser/lib/esm/impl/parser.js
+var ParseOptions;
+(function(ParseOptions2) {
+  ParseOptions2.DEFAULT = {
+    allowTrailingComma: false
+  };
+})(ParseOptions || (ParseOptions = {}));
+function parseTree(text, errors = [], options = ParseOptions.DEFAULT) {
+  let currentParent = { type: "array", offset: -1, length: -1, children: [], parent: void 0 };
+  function ensurePropertyComplete(endOffset) {
+    if (currentParent.type === "property") {
+      currentParent.length = endOffset - currentParent.offset;
+      currentParent = currentParent.parent;
+    }
+  }
+  function onValue(valueNode) {
+    currentParent.children.push(valueNode);
+    return valueNode;
+  }
+  const visitor = {
+    onObjectBegin: (offset) => {
+      currentParent = onValue({ type: "object", offset, length: -1, parent: currentParent, children: [] });
+    },
+    onObjectProperty: (name, offset, length) => {
+      currentParent = onValue({ type: "property", offset, length: -1, parent: currentParent, children: [] });
+      currentParent.children.push({ type: "string", value: name, offset, length, parent: currentParent });
+    },
+    onObjectEnd: (offset, length) => {
+      ensurePropertyComplete(offset + length);
+      currentParent.length = offset + length - currentParent.offset;
+      currentParent = currentParent.parent;
+      ensurePropertyComplete(offset + length);
+    },
+    onArrayBegin: (offset, length) => {
+      currentParent = onValue({ type: "array", offset, length: -1, parent: currentParent, children: [] });
+    },
+    onArrayEnd: (offset, length) => {
+      currentParent.length = offset + length - currentParent.offset;
+      currentParent = currentParent.parent;
+      ensurePropertyComplete(offset + length);
+    },
+    onLiteralValue: (value, offset, length) => {
+      onValue({ type: getNodeType(value), offset, length, parent: currentParent, value });
+      ensurePropertyComplete(offset + length);
+    },
+    onSeparator: (sep, offset, length) => {
+      if (currentParent.type === "property") {
+        if (sep === ":") {
+          currentParent.colonOffset = offset;
+        } else if (sep === ",") {
+          ensurePropertyComplete(offset);
+        }
+      }
+    },
+    onError: (error, offset, length) => {
+      errors.push({ error, offset, length });
+    }
+  };
+  visit(text, visitor, options);
+  const result = currentParent.children[0];
+  if (result) {
+    delete result.parent;
+  }
+  return result;
+}
+function findNodeAtLocation(root, path) {
+  if (!root) {
+    return void 0;
+  }
+  let node = root;
+  for (let segment of path) {
+    if (typeof segment === "string") {
+      if (node.type !== "object" || !Array.isArray(node.children)) {
+        return void 0;
+      }
+      let found = false;
+      for (const propertyNode of node.children) {
+        if (Array.isArray(propertyNode.children) && propertyNode.children[0].value === segment && propertyNode.children.length === 2) {
+          node = propertyNode.children[1];
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        return void 0;
+      }
+    } else {
+      const index = segment;
+      if (node.type !== "array" || index < 0 || !Array.isArray(node.children) || index >= node.children.length) {
+        return void 0;
+      }
+      node = node.children[index];
+    }
+  }
+  return node;
+}
+function visit(text, visitor, options = ParseOptions.DEFAULT) {
+  const _scanner = createScanner(text, false);
+  const _jsonPath = [];
+  let suppressedCallbacks = 0;
+  function toNoArgVisit(visitFunction) {
+    return visitFunction ? () => suppressedCallbacks === 0 && visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisit(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisitWithPath(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
+  }
+  function toBeginVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks++;
+      } else {
+        let cbReturn = visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice());
+        if (cbReturn === false) {
+          suppressedCallbacks = 1;
+        }
+      }
+    } : () => true;
+  }
+  function toEndVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks--;
+      }
+      if (suppressedCallbacks === 0) {
+        visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());
+      }
+    } : () => true;
+  }
+  const onObjectBegin = toBeginVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toEndVisit(visitor.onObjectEnd), onArrayBegin = toBeginVisit(visitor.onArrayBegin), onArrayEnd = toEndVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
+  const disallowComments = options && options.disallowComments;
+  const allowTrailingComma = options && options.allowTrailingComma;
+  function scanNext() {
+    while (true) {
+      const token = _scanner.scan();
+      switch (_scanner.getTokenError()) {
+        case 4:
+          handleError(
+            14
+            /* ParseErrorCode.InvalidUnicode */
+          );
+          break;
+        case 5:
+          handleError(
+            15
+            /* ParseErrorCode.InvalidEscapeCharacter */
+          );
+          break;
+        case 3:
+          handleError(
+            13
+            /* ParseErrorCode.UnexpectedEndOfNumber */
+          );
+          break;
+        case 1:
+          if (!disallowComments) {
+            handleError(
+              11
+              /* ParseErrorCode.UnexpectedEndOfComment */
+            );
+          }
+          break;
+        case 2:
+          handleError(
+            12
+            /* ParseErrorCode.UnexpectedEndOfString */
+          );
+          break;
+        case 6:
+          handleError(
+            16
+            /* ParseErrorCode.InvalidCharacter */
+          );
+          break;
+      }
+      switch (token) {
+        case 12:
+        case 13:
+          if (disallowComments) {
+            handleError(
+              10
+              /* ParseErrorCode.InvalidCommentToken */
+            );
+          } else {
+            onComment();
+          }
+          break;
+        case 16:
+          handleError(
+            1
+            /* ParseErrorCode.InvalidSymbol */
+          );
+          break;
+        case 15:
+        case 14:
+          break;
+        default:
+          return token;
+      }
+    }
+  }
+  function handleError(error, skipUntilAfter = [], skipUntil = []) {
+    onError(error);
+    if (skipUntilAfter.length + skipUntil.length > 0) {
+      let token = _scanner.getToken();
+      while (token !== 17) {
+        if (skipUntilAfter.indexOf(token) !== -1) {
+          scanNext();
+          break;
+        } else if (skipUntil.indexOf(token) !== -1) {
+          break;
+        }
+        token = scanNext();
+      }
+    }
+  }
+  function parseString(isValue) {
+    const value = _scanner.getTokenValue();
+    if (isValue) {
+      onLiteralValue(value);
+    } else {
+      onObjectProperty(value);
+      _jsonPath.push(value);
+    }
+    scanNext();
+    return true;
+  }
+  function parseLiteral() {
+    switch (_scanner.getToken()) {
+      case 11:
+        const tokenValue = _scanner.getTokenValue();
+        let value = Number(tokenValue);
+        if (isNaN(value)) {
+          handleError(
+            2
+            /* ParseErrorCode.InvalidNumberFormat */
+          );
+          value = 0;
+        }
+        onLiteralValue(value);
+        break;
+      case 7:
+        onLiteralValue(null);
+        break;
+      case 8:
+        onLiteralValue(true);
+        break;
+      case 9:
+        onLiteralValue(false);
+        break;
+      default:
+        return false;
+    }
+    scanNext();
+    return true;
+  }
+  function parseProperty() {
+    if (_scanner.getToken() !== 10) {
+      handleError(3, [], [
+        2,
+        5
+        /* SyntaxKind.CommaToken */
+      ]);
+      return false;
+    }
+    parseString(false);
+    if (_scanner.getToken() === 6) {
+      onSeparator(":");
+      scanNext();
+      if (!parseValue()) {
+        handleError(4, [], [
+          2,
+          5
+          /* SyntaxKind.CommaToken */
+        ]);
+      }
+    } else {
+      handleError(5, [], [
+        2,
+        5
+        /* SyntaxKind.CommaToken */
+      ]);
+    }
+    _jsonPath.pop();
+    return true;
+  }
+  function parseObject() {
+    onObjectBegin();
+    scanNext();
+    let needsComma = false;
+    while (_scanner.getToken() !== 2 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 2 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (!parseProperty()) {
+        handleError(4, [], [
+          2,
+          5
+          /* SyntaxKind.CommaToken */
+        ]);
+      }
+      needsComma = true;
+    }
+    onObjectEnd();
+    if (_scanner.getToken() !== 2) {
+      handleError(7, [
+        2
+        /* SyntaxKind.CloseBraceToken */
+      ], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseArray() {
+    onArrayBegin();
+    scanNext();
+    let isFirstElement = true;
+    let needsComma = false;
+    while (_scanner.getToken() !== 4 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 4 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (isFirstElement) {
+        _jsonPath.push(0);
+        isFirstElement = false;
+      } else {
+        _jsonPath[_jsonPath.length - 1]++;
+      }
+      if (!parseValue()) {
+        handleError(4, [], [
+          4,
+          5
+          /* SyntaxKind.CommaToken */
+        ]);
+      }
+      needsComma = true;
+    }
+    onArrayEnd();
+    if (!isFirstElement) {
+      _jsonPath.pop();
+    }
+    if (_scanner.getToken() !== 4) {
+      handleError(8, [
+        4
+        /* SyntaxKind.CloseBracketToken */
+      ], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseValue() {
+    switch (_scanner.getToken()) {
+      case 3:
+        return parseArray();
+      case 1:
+        return parseObject();
+      case 10:
+        return parseString(true);
+      default:
+        return parseLiteral();
+    }
+  }
+  scanNext();
+  if (_scanner.getToken() === 17) {
+    if (options.allowEmptyContent) {
+      return true;
+    }
+    handleError(4, [], []);
+    return false;
+  }
+  if (!parseValue()) {
+    handleError(4, [], []);
+    return false;
+  }
+  if (_scanner.getToken() !== 17) {
+    handleError(9, [], []);
+  }
+  return true;
+}
+function getNodeType(value) {
+  switch (typeof value) {
+    case "boolean":
+      return "boolean";
+    case "number":
+      return "number";
+    case "string":
+      return "string";
+    case "object": {
+      if (!value) {
+        return "null";
+      } else if (Array.isArray(value)) {
+        return "array";
+      }
+      return "object";
+    }
+    default:
+      return "null";
+  }
+}
+
+// ../../node_modules/jsonc-parser/lib/esm/main.js
+var ScanError;
+(function(ScanError2) {
+  ScanError2[ScanError2["None"] = 0] = "None";
+  ScanError2[ScanError2["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+  ScanError2[ScanError2["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+  ScanError2[ScanError2["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+  ScanError2[ScanError2["InvalidUnicode"] = 4] = "InvalidUnicode";
+  ScanError2[ScanError2["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+  ScanError2[ScanError2["InvalidCharacter"] = 6] = "InvalidCharacter";
+})(ScanError || (ScanError = {}));
+var SyntaxKind;
+(function(SyntaxKind2) {
+  SyntaxKind2[SyntaxKind2["OpenBraceToken"] = 1] = "OpenBraceToken";
+  SyntaxKind2[SyntaxKind2["CloseBraceToken"] = 2] = "CloseBraceToken";
+  SyntaxKind2[SyntaxKind2["OpenBracketToken"] = 3] = "OpenBracketToken";
+  SyntaxKind2[SyntaxKind2["CloseBracketToken"] = 4] = "CloseBracketToken";
+  SyntaxKind2[SyntaxKind2["CommaToken"] = 5] = "CommaToken";
+  SyntaxKind2[SyntaxKind2["ColonToken"] = 6] = "ColonToken";
+  SyntaxKind2[SyntaxKind2["NullKeyword"] = 7] = "NullKeyword";
+  SyntaxKind2[SyntaxKind2["TrueKeyword"] = 8] = "TrueKeyword";
+  SyntaxKind2[SyntaxKind2["FalseKeyword"] = 9] = "FalseKeyword";
+  SyntaxKind2[SyntaxKind2["StringLiteral"] = 10] = "StringLiteral";
+  SyntaxKind2[SyntaxKind2["NumericLiteral"] = 11] = "NumericLiteral";
+  SyntaxKind2[SyntaxKind2["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+  SyntaxKind2[SyntaxKind2["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+  SyntaxKind2[SyntaxKind2["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+  SyntaxKind2[SyntaxKind2["Trivia"] = 15] = "Trivia";
+  SyntaxKind2[SyntaxKind2["Unknown"] = 16] = "Unknown";
+  SyntaxKind2[SyntaxKind2["EOF"] = 17] = "EOF";
+})(SyntaxKind || (SyntaxKind = {}));
+var parseTree2 = parseTree;
+var findNodeAtLocation2 = findNodeAtLocation;
+var ParseErrorCode;
+(function(ParseErrorCode2) {
+  ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
+  ParseErrorCode2[ParseErrorCode2["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+  ParseErrorCode2[ParseErrorCode2["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+  ParseErrorCode2[ParseErrorCode2["ValueExpected"] = 4] = "ValueExpected";
+  ParseErrorCode2[ParseErrorCode2["ColonExpected"] = 5] = "ColonExpected";
+  ParseErrorCode2[ParseErrorCode2["CommaExpected"] = 6] = "CommaExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+  ParseErrorCode2[ParseErrorCode2["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+  ParseErrorCode2[ParseErrorCode2["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+  ParseErrorCode2[ParseErrorCode2["InvalidUnicode"] = 14] = "InvalidUnicode";
+  ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+  ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
+})(ParseErrorCode || (ParseErrorCode = {}));
+
+// ../core/src/model.ts
+function findDevice(topology, name) {
+  return topology.devices.find((d) => d.name === name);
+}
+function findNetwork(topology, name) {
+  return (topology.networks ?? []).find((n) => n.name === name);
+}
+
+// ../core/src/parse.ts
+var TopoParseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TopoParseError";
+  }
+};
+function parse2(text) {
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch (e) {
+    throw new TopoParseError(`invalid JSON: ${e.message}`);
+  }
+  return normalize(value);
+}
+function normalize(value) {
+  if (!isPlainObject(value)) {
+    throw new TopoParseError("top level must be a JSON object");
+  }
+  if (!Array.isArray(value.devices)) {
+    throw new TopoParseError('no "devices" array found');
+  }
+  if ("version" in value && value.version !== void 0 && value.version !== 1) {
+    throw new TopoParseError(
+      `unsupported version ${JSON.stringify(value.version)} (this build reads format v1)`
+    );
+  }
+  const devices = value.devices.map((raw, i) => normalizeDevice(raw, i)).filter((d) => d !== void 0);
+  const provider_networks = asArray(value.provider_networks).map((raw, i) => normalizeProviderNetwork(raw, i)).filter((p) => p !== void 0);
+  const networks = asArray(value.networks).map((raw, i) => normalizeNetwork(raw, i)).filter((n) => n !== void 0);
+  const cables = asArray(value.cables).filter(isPlainObject).map((raw) => normalizeCable(raw));
+  const circuits = asArray(value.circuits).filter(isPlainObject).map((raw) => normalizeCircuit(raw));
+  const logical_links = asArray(value.logical_links).filter(isPlainObject).map((raw) => normalizeLogicalLink(raw, devices));
+  const topology = { devices };
+  const schema = nonEmptyString(value.$schema);
+  if (schema !== void 0) topology.$schema = schema;
+  if (value.version === 1) topology.version = 1;
+  if (provider_networks.length) topology.provider_networks = provider_networks;
+  if (networks.length) topology.networks = networks;
+  if (cables.length) topology.cables = cables;
+  if (circuits.length) topology.circuits = circuits;
+  if (logical_links.length) topology.logical_links = logical_links;
+  return reorderTopology(topology);
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function asArray(v) {
+  return Array.isArray(v) ? v : [];
+}
+function nonEmptyString(v) {
+  return typeof v === "string" && v !== "" ? v : void 0;
+}
+function trimmedString(v) {
+  const s = typeof v === "string" ? v.trim() : "";
+  return s === "" ? void 0 : s;
+}
+function normalizePosition(v) {
+  if (!isPlainObject(v)) return void 0;
+  const x = v.x;
+  const y = v.y;
+  if (typeof x !== "number" || typeof y !== "number") return void 0;
+  if (!Number.isFinite(x) || !Number.isFinite(y)) return void 0;
+  return { x: Math.round(x), y: Math.round(y) };
+}
+function normalizeInterface(raw) {
+  if (!isPlainObject(raw)) return void 0;
+  const f = {};
+  const name = nonEmptyString(raw.name);
+  const ip = nonEmptyString(raw.ip_address);
+  const type = nonEmptyString(raw.type);
+  const description = nonEmptyString(raw.description);
+  const lag = nonEmptyString(raw.lag);
+  const vrf = nonEmptyString(raw.vrf);
+  if (name !== void 0) f.name = name;
+  if (ip !== void 0) f.ip_address = ip;
+  if (type !== void 0) f.type = type;
+  if (description !== void 0) f.description = description;
+  if (lag !== void 0) f.lag = lag;
+  if (vrf !== void 0) f.vrf = vrf;
+  return Object.keys(f).length ? f : void 0;
+}
+function normalizeDevice(raw, index) {
+  if (!isPlainObject(raw)) return void 0;
+  const d = {
+    name: nonEmptyString(raw.name) ?? `node-${index + 1}`
+  };
+  const device_type = nonEmptyString(raw.device_type);
+  const role = nonEmptyString(raw.role);
+  const site = nonEmptyString(raw.site);
+  const tenant = nonEmptyString(raw.tenant);
+  const platform = nonEmptyString(raw.platform);
+  if (device_type !== void 0) d.device_type = device_type;
+  if (role !== void 0) d.role = role;
+  if (site !== void 0) d.site = site;
+  if (tenant !== void 0) d.tenant = tenant;
+  if (platform !== void 0) d.platform = platform;
+  const vrfs = asArray(raw.vrfs).map((v) => String(v).trim()).filter(Boolean);
+  if (vrfs.length) d.vrfs = vrfs;
+  const interfaces = asArray(raw.interfaces).map(normalizeInterface).filter((f) => f !== void 0);
+  if (interfaces.length) d.interfaces = interfaces;
+  if (isPlainObject(raw.config_context) && Object.keys(raw.config_context).length) {
+    d.config_context = raw.config_context;
+  }
+  const position = normalizePosition(raw.position);
+  if (position) d.position = position;
+  return d;
+}
+function normalizeProviderNetwork(raw, index) {
+  if (!isPlainObject(raw)) return void 0;
+  const p = {
+    name: nonEmptyString(raw.name) ?? `pnet-${index + 1}`
+  };
+  const provider = nonEmptyString(raw.provider);
+  const description = nonEmptyString(raw.description);
+  if (provider !== void 0) p.provider = provider;
+  if (description !== void 0) p.description = description;
+  const position = normalizePosition(raw.position);
+  if (position) p.position = position;
+  return p;
+}
+function normalizeNetwork(raw, index) {
+  if (!isPlainObject(raw)) return void 0;
+  const n = {
+    name: nonEmptyString(raw.name) ?? `net-${index + 1}`
+  };
+  const prefix = nonEmptyString(raw.prefix);
+  const vlan = nonEmptyString(raw.vlan);
+  const description = nonEmptyString(raw.description);
+  if (prefix !== void 0) n.prefix = prefix;
+  if (vlan !== void 0) n.vlan = vlan;
+  if (isPlainObject(raw.fhrp)) {
+    const fhrp = {};
+    const protocol = nonEmptyString(raw.fhrp.protocol);
+    const group_id = nonEmptyString(raw.fhrp.group_id) ?? nonEmptyString(raw.fhrp.group);
+    const virtual_ip = nonEmptyString(raw.fhrp.virtual_ip);
+    if (protocol !== void 0) fhrp.protocol = protocol;
+    if (group_id !== void 0) fhrp.group_id = group_id;
+    if (virtual_ip !== void 0) fhrp.virtual_ip = virtual_ip;
+    if (Object.keys(fhrp).length) n.fhrp = fhrp;
+  }
+  if (description !== void 0) n.description = description;
+  const position = normalizePosition(raw.position);
+  if (position) n.position = position;
+  return n;
+}
+function normalizePhysicalEndpoint(raw, keepSite) {
+  if (!isPlainObject(raw)) return {};
+  const pn = nonEmptyString(raw.provider_network);
+  if (pn !== void 0) return { provider_network: pn };
+  const ep = {};
+  const site = keepSite ? nonEmptyString(raw.site) : void 0;
+  const device = nonEmptyString(raw.device);
+  const iface = nonEmptyString(raw.interface);
+  if (site !== void 0) ep.site = site;
+  if (device !== void 0) ep.device = device;
+  if (iface !== void 0) ep.interface = iface;
+  return ep;
+}
+function normalizeCable(raw) {
+  const c = {
+    a: normalizePhysicalEndpoint(raw.a, false),
+    b: normalizePhysicalEndpoint(raw.b, false)
+  };
+  const type = nonEmptyString(raw.type);
+  const bandwidth = nonEmptyString(raw.bandwidth);
+  const status = nonEmptyString(raw.status);
+  const label = nonEmptyString(raw.label);
+  if (type !== void 0) c.type = type;
+  if (bandwidth !== void 0) c.bandwidth = bandwidth;
+  if (status !== void 0) c.status = status;
+  if (label !== void 0) c.label = label;
+  return c;
+}
+function normalizeCircuit(raw) {
+  const c = {
+    a: normalizePhysicalEndpoint(raw.a, true),
+    b: normalizePhysicalEndpoint(raw.b, true)
+  };
+  const cid = nonEmptyString(raw.cid);
+  const provider = nonEmptyString(raw.provider);
+  const type = nonEmptyString(raw.type);
+  const commit_rate = nonEmptyString(raw.commit_rate);
+  const status = nonEmptyString(raw.status);
+  if (cid !== void 0) c.cid = cid;
+  if (provider !== void 0) c.provider = provider;
+  if (type !== void 0) c.type = type;
+  if (commit_rate !== void 0) c.commit_rate = commit_rate;
+  if (status !== void 0) c.status = status;
+  return c;
+}
+function ensureInterface(device, name) {
+  device.interfaces = device.interfaces ?? [];
+  let f = device.interfaces.find((x) => x.name === name);
+  if (!f) {
+    f = { name };
+    device.interfaces.push(f);
+  }
+  return f;
+}
+function normalizeLogicalEndpoint(raw, topLevelVrf, devices) {
+  if (!isPlainObject(raw)) return {};
+  const pn = nonEmptyString(raw.provider_network);
+  if (pn !== void 0) {
+    const ep2 = { provider_network: pn };
+    const id2 = trimmedString(raw.id);
+    if (id2 !== void 0) ep2.id = id2;
+    return ep2;
+  }
+  const net = nonEmptyString(raw.network);
+  if (net !== void 0) return { network: net };
+  const ep = {};
+  const device = nonEmptyString(raw.device);
+  const vrf = trimmedString(raw.vrf) ?? topLevelVrf;
+  const id = trimmedString(raw.id);
+  const iface = nonEmptyString(raw.interface);
+  const ip = nonEmptyString(raw.ip_address);
+  if (device !== void 0) ep.device = device;
+  if (vrf !== void 0) ep.vrf = vrf;
+  if (id !== void 0) ep.id = id;
+  if (iface !== void 0) ep.interface = iface;
+  const target = device !== void 0 ? devices.find((d) => d.name === device) : void 0;
+  if (iface !== void 0 && ip !== void 0 && target) {
+    const f = ensureInterface(target, iface);
+    if (!f.ip_address) f.ip_address = ip;
+    if (vrf !== void 0 && !f.vrf) f.vrf = vrf;
+  } else if (ip !== void 0) {
+    ep.ip_address = ip;
+  }
+  return ep;
+}
+function normalizeLogicalLink(raw, devices) {
+  const topLevelVrf = trimmedString(raw.vrf);
+  const l = {
+    a: normalizeLogicalEndpoint(raw.a, topLevelVrf, devices),
+    b: normalizeLogicalEndpoint(raw.b, topLevelVrf, devices)
+  };
+  const link_id = nonEmptyString(raw.link_id);
+  const vlan = nonEmptyString(raw.vlan);
+  const label = nonEmptyString(raw.label);
+  const description = nonEmptyString(raw.description);
+  if (link_id !== void 0) l.link_id = link_id;
+  if (vlan !== void 0) l.vlan = vlan;
+  if (label !== void 0) l.label = label;
+  if (description !== void 0) l.description = description;
+  return l;
+}
+function reorderTopology(t) {
+  const out = {};
+  if (t.$schema !== void 0) out.$schema = t.$schema;
+  if (t.version !== void 0) out.version = t.version;
+  out.devices = t.devices;
+  if (t.provider_networks) out.provider_networks = t.provider_networks;
+  if (t.networks) out.networks = t.networks;
+  if (t.cables) out.cables = t.cables;
+  if (t.circuits) out.circuits = t.circuits;
+  if (t.logical_links) out.logical_links = t.logical_links;
+  return out;
+}
+
+// ../core/src/unknownFields.ts
+var TOP_LEVEL = ["$schema", "version", "devices", "provider_networks", "networks", "cables", "circuits", "logical_links"];
+var DEVICE = ["name", "device_type", "role", "site", "tenant", "platform", "vrfs", "interfaces", "config_context", "position"];
+var INTERFACE = ["name", "ip_address", "type", "description", "lag", "vrf"];
+var PROVIDER_NETWORK = ["name", "provider", "description", "position"];
+var NETWORK = ["name", "prefix", "vlan", "fhrp", "description", "position"];
+var FHRP = ["protocol", "group_id", "virtual_ip"];
+var POSITION = ["x", "y"];
+var CABLE = ["a", "b", "type", "bandwidth", "status", "label"];
+var CIRCUIT = ["a", "b", "cid", "provider", "type", "commit_rate", "status"];
+var LOGICAL_LINK = ["a", "b", "link_id", "vlan", "label", "description", "vrf"];
+var PHYSICAL_ENDPOINT = ["site", "device", "interface", "provider_network"];
+var LOGICAL_ENDPOINT = ["device", "vrf", "id", "interface", "ip_address", "provider_network", "network"];
+function levenshtein(a, b) {
+  let prev = Array.from({ length: b.length + 1 }, (_, j) => j);
+  for (let i = 1; i <= a.length; i++) {
+    const cur = [i];
+    for (let j = 1; j <= b.length; j++) {
+      cur[j] = Math.min(
+        (prev[j] ?? 0) + 1,
+        (cur[j - 1] ?? 0) + 1,
+        (prev[j - 1] ?? 0) + (a[i - 1] === b[j - 1] ? 0 : 1)
+      );
+    }
+    prev = cur;
+  }
+  return prev[b.length] ?? 0;
+}
+function isSubsequence(needle, haystack) {
+  let i = 0;
+  for (const c of haystack) {
+    if (c === needle[i]) i++;
+    if (i === needle.length) return true;
+  }
+  return i === needle.length;
+}
+function suggestField(field, known) {
+  const lower = field.toLowerCase();
+  const prefix = known.filter((k) => {
+    const kl = k.toLowerCase();
+    return Math.min(kl.length, lower.length) >= 2 && (kl.startsWith(lower) || lower.startsWith(kl));
+  }).sort((x, y) => x.length - y.length)[0];
+  if (prefix) return prefix;
+  if (lower.length >= 3) {
+    const subsequence = known.filter((k) => isSubsequence(lower, k.toLowerCase()));
+    if (subsequence.length === 1) return subsequence[0];
+  }
+  let best;
+  let bestDist = 3;
+  for (const k of known) {
+    const d = levenshtein(lower, k.toLowerCase());
+    if (d < bestDist) {
+      bestDist = d;
+      best = k;
+    }
+  }
+  return best;
+}
+function isPlainObject2(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function findUnknownFields(value) {
+  const findings = [];
+  if (!isPlainObject2(value)) return findings;
+  const check = (obj, known, path) => {
+    if (!isPlainObject2(obj)) return;
+    for (const key of Object.keys(obj)) {
+      if (!known.includes(key)) {
+        const suggestion = suggestField(key, known);
+        findings.push({ path: [...path, key], field: key, ...suggestion ? { suggestion } : {} });
+      }
+    }
+  };
+  const checkArray = (arr, path, fn) => {
+    if (!Array.isArray(arr)) return;
+    arr.forEach((item, i) => fn(item, [...path, i]));
+  };
+  check(value, TOP_LEVEL, []);
+  checkArray(value.devices, ["devices"], (d, p) => {
+    check(d, DEVICE, p);
+    if (isPlainObject2(d)) {
+      checkArray(d.interfaces, [...p, "interfaces"], (f, fp) => check(f, INTERFACE, fp));
+      check(d.position, POSITION, [...p, "position"]);
+    }
+  });
+  checkArray(value.provider_networks, ["provider_networks"], (pn, p) => {
+    check(pn, PROVIDER_NETWORK, p);
+    if (isPlainObject2(pn)) check(pn.position, POSITION, [...p, "position"]);
+  });
+  checkArray(value.networks, ["networks"], (n, p) => {
+    check(n, NETWORK, p);
+    if (isPlainObject2(n)) {
+      check(n.fhrp, FHRP, [...p, "fhrp"]);
+      check(n.position, POSITION, [...p, "position"]);
+    }
+  });
+  const checkLinks = (key, linkKnown, endpointKnown) => checkArray(value[key], [key], (l, p) => {
+    check(l, linkKnown, p);
+    if (isPlainObject2(l)) {
+      check(l.a, endpointKnown, [...p, "a"]);
+      check(l.b, endpointKnown, [...p, "b"]);
+    }
+  });
+  checkLinks("cables", CABLE, PHYSICAL_ENDPOINT);
+  checkLinks("circuits", CIRCUIT, PHYSICAL_ENDPOINT);
+  checkLinks("logical_links", LOGICAL_LINK, LOGICAL_ENDPOINT);
+  return findings;
+}
+
+// ../core/src/cidr.ts
+function parseIpv4(ip) {
+  const bare = ip.split("/")[0] ?? "";
+  const parts = bare.trim().split(".");
+  if (parts.length !== 4) return null;
+  let out = 0;
+  for (const part of parts) {
+    if (!/^\d{1,3}$/.test(part)) return null;
+    const n = Number(part);
+    if (n > 255) return null;
+    out = out << 8 | n;
+  }
+  return out >>> 0;
+}
+function ipv4InCidr(ip, cidr) {
+  const [base, lenStr] = cidr.trim().split("/");
+  if (base === void 0 || lenStr === void 0 || !/^\d{1,2}$/.test(lenStr)) return null;
+  const len = Number(lenStr);
+  if (len < 0 || len > 32) return null;
+  const baseN = parseIpv4(base);
+  const ipN = parseIpv4(ip);
+  if (baseN === null || ipN === null) return null;
+  if (len === 0) return true;
+  const mask = 4294967295 << 32 - len >>> 0;
+  return (baseN & mask) === (ipN & mask);
+}
+
+// ../core/src/validate.ts
+function validate(topology) {
+  const diagnostics = [];
+  if (topology.version === void 0) {
+    diagnostics.push({
+      severity: "info",
+      code: "missing-version",
+      message: 'File has no "version" field (legacy TopoDraft export); saving will add "version": 1.',
+      path: []
+    });
+  }
+  const seen = /* @__PURE__ */ new Map();
+  topology.devices.forEach((d, i) => {
+    if (seen.has(d.name)) {
+      diagnostics.push({
+        severity: "error",
+        code: "duplicate-name",
+        message: `Duplicate name "${d.name}" (already used by a ${seen.get(d.name)}); link references resolve to the first occurrence.`,
+        path: ["devices", i, "name"]
+      });
+    } else {
+      seen.set(d.name, "device");
+    }
+  });
+  (topology.provider_networks ?? []).forEach((p, i) => {
+    if (seen.has(p.name)) {
+      diagnostics.push({
+        severity: "error",
+        code: "duplicate-name",
+        message: `Duplicate name "${p.name}" (already used by a ${seen.get(p.name)}); link references resolve to the first occurrence.`,
+        path: ["provider_networks", i, "name"]
+      });
+    } else {
+      seen.set(p.name, "provider network");
+    }
+  });
+  (topology.networks ?? []).forEach((n, i) => {
+    if (seen.has(n.name)) {
+      diagnostics.push({
+        severity: "error",
+        code: "duplicate-name",
+        message: `Duplicate name "${n.name}" (already used by a ${seen.get(n.name)}); link references resolve to the first occurrence.`,
+        path: ["networks", i, "name"]
+      });
+    } else {
+      seen.set(n.name, "network");
+    }
+  });
+  const deviceNames = new Set(topology.devices.map((d) => d.name));
+  const pnNames = new Set((topology.provider_networks ?? []).map((p) => p.name));
+  const networkNames = new Set((topology.networks ?? []).map((n) => n.name));
+  const checkEndpoint = (collection, index, side, ep) => {
+    const base = [collection, index, side];
+    const netRef = ep.network;
+    if (netRef !== void 0) {
+      if (!networkNames.has(netRef)) {
+        diagnostics.push({
+          severity: "error",
+          code: "dangling-reference",
+          message: `Endpoint references network "${netRef}", which does not exist in networks[].`,
+          path: [...base, "network"]
+        });
+      }
+      return;
+    }
+    if (ep.provider_network !== void 0) {
+      if (!pnNames.has(ep.provider_network)) {
+        diagnostics.push({
+          severity: "error",
+          code: "dangling-reference",
+          message: `Endpoint references provider network "${ep.provider_network}", which does not exist in provider_networks[].`,
+          path: [...base, "provider_network"]
+        });
+      }
+      return;
+    }
+    if (ep.device === void 0) {
+      diagnostics.push({
+        severity: "error",
+        code: "dangling-reference",
+        message: 'Endpoint references neither a "device", a "provider_network", nor a "network".',
+        path: base
+      });
+      return;
+    }
+    if (!deviceNames.has(ep.device)) {
+      diagnostics.push({
+        severity: "error",
+        code: "dangling-reference",
+        message: `Endpoint references device "${ep.device}", which does not exist in devices[].`,
+        path: [...base, "device"]
+      });
+      return;
+    }
+    const device = findDevice(topology, ep.device);
+    if (!device) return;
+    if (ep.interface !== void 0) {
+      const exists = (device.interfaces ?? []).some((f) => f.name === ep.interface);
+      if (!exists) {
+        diagnostics.push({
+          severity: "warning",
+          code: "unknown-interface",
+          message: `Interface "${ep.interface}" does not exist on device "${ep.device}".`,
+          path: [...base, "interface"]
+        });
+      }
+    }
+    if (collection === "logical_links") {
+      const vrf = (ep.vrf ?? "").trim();
+      if (vrf) {
+        const declared = new Set((device.vrfs ?? []).map((v) => v.trim()).filter(Boolean));
+        for (const f of device.interfaces ?? []) {
+          const v = (f.vrf ?? "").trim();
+          if (v) declared.add(v);
+        }
+        if (!declared.has(vrf)) {
+          diagnostics.push({
+            severity: "warning",
+            code: "undeclared-vrf",
+            message: `VRF "${vrf}" on device "${ep.device}" is neither declared in devices[].vrfs nor used by any interface. The editor derives a device's VRF compartments as vrfs[] \u222A interfaces[].vrf \u222A logical-endpoint VRFs, so it will still render \u2014 but declaring it explicitly is recommended.`,
+            path: [...base, "vrf"]
+          });
+        }
+      }
+    }
+  };
+  (topology.cables ?? []).forEach((c, i) => {
+    checkEndpoint("cables", i, "a", c.a ?? {});
+    checkEndpoint("cables", i, "b", c.b ?? {});
+  });
+  (topology.circuits ?? []).forEach((c, i) => {
+    checkEndpoint("circuits", i, "a", c.a ?? {});
+    checkEndpoint("circuits", i, "b", c.b ?? {});
+  });
+  (topology.logical_links ?? []).forEach((l, i) => {
+    checkEndpoint("logical_links", i, "a", l.a ?? {});
+    checkEndpoint("logical_links", i, "b", l.b ?? {});
+  });
+  topology.devices.forEach((d, di) => {
+    (d.interfaces ?? []).forEach((f, fi) => {
+      if (f.lag === void 0) return;
+      const parentExists = (d.interfaces ?? []).some((x) => x.name === f.lag);
+      if (!parentExists) {
+        diagnostics.push({
+          severity: "warning",
+          code: "missing-lag-parent",
+          message: `Interface "${f.name ?? ""}" on device "${d.name}" names LAG parent "${f.lag}", but no such interface exists on the same device.`,
+          path: ["devices", di, "interfaces", fi, "lag"]
+        });
+      }
+    });
+  });
+  (topology.networks ?? []).forEach((n, ni) => {
+    const prefix = (n.prefix ?? "").trim();
+    if (!prefix) return;
+    const vip = (n.fhrp?.virtual_ip ?? "").trim();
+    if (vip && ipv4InCidr(vip, prefix) === false) {
+      diagnostics.push({
+        severity: "warning",
+        code: "ip-outside-prefix",
+        message: `FHRP virtual IP "${vip}" is outside this network's prefix ${prefix}.`,
+        path: ["networks", ni, "fhrp", "virtual_ip"]
+      });
+    }
+  });
+  (topology.logical_links ?? []).forEach((l, li) => {
+    const sides = ["a", "b"];
+    for (const side of sides) {
+      const other = side === "a" ? "b" : "a";
+      const netName = l[other].network;
+      if (netName === void 0) continue;
+      const prefix = (findNetwork(topology, netName)?.prefix ?? "").trim();
+      if (!prefix) continue;
+      const ep = l[side];
+      if (ep.device === void 0) continue;
+      let ip = (ep.ip_address ?? "").trim();
+      let path = ["logical_links", li, side, "ip_address"];
+      if (!ip && ep.interface !== void 0) {
+        const device = findDevice(topology, ep.device);
+        const ifIdx = (device?.interfaces ?? []).findIndex((f) => f.name === ep.interface);
+        const iface = ifIdx >= 0 ? device?.interfaces?.[ifIdx] : void 0;
+        if (iface?.ip_address) {
+          ip = iface.ip_address.trim();
+          const di = topology.devices.findIndex((d) => d.name === ep.device);
+          path = ["devices", di, "interfaces", ifIdx, "ip_address"];
+        }
+      }
+      if (ip && ipv4InCidr(ip, prefix) === false) {
+        diagnostics.push({
+          severity: "warning",
+          code: "ip-outside-prefix",
+          message: `IP "${ip}" on "${ep.device}" is outside the prefix ${prefix} of network "${netName}".`,
+          path
+        });
+      }
+    }
+  });
+  return diagnostics;
+}
+
+// ../extension/src/diagnostics.ts
+function resolveNode(root, path) {
+  for (let p = [...path]; p.length; p.pop()) {
+    const node = findNodeAtLocation2(root, p);
+    if (node) return node;
+  }
+  return root;
+}
+function computeOffsetDiagnostics(text) {
+  let topology;
+  try {
+    topology = parse2(text);
+  } catch {
+    return [];
+  }
+  const semantic = validate(topology);
+  const unknown = findUnknownFields(JSON.parse(text));
+  if (!semantic.length && !unknown.length) return [];
+  const root = parseTree2(text);
+  const out = unknown.map((f) => {
+    const valueNode = root ? resolveNode(root, f.path) : void 0;
+    const node = valueNode?.parent?.type === "property" ? valueNode.parent : valueNode;
+    const atRoot = !node || node === root;
+    return {
+      severity: "warning",
+      code: "unknown-field",
+      message: `Unknown field "${f.field}"` + (f.suggestion ? ` \u2014 did you mean "${f.suggestion}"?` : "") + ' Unknown fields are dropped when the editor saves. See the JSON Schema (topodraft.schema.json) or run "TopoDraft: Write AI Agent Guide (AGENTS.md)".',
+      start: node && !atRoot ? node.offset : root?.offset ?? 0,
+      length: node && !atRoot ? node.length : 1
+    };
+  });
+  for (const d of semantic) {
+    const node = root ? resolveNode(root, d.path) : void 0;
+    const atRoot = !node || node === root;
+    out.push({
+      severity: d.severity,
+      code: d.code,
+      message: d.message,
+      start: node && !atRoot ? node.offset : root?.offset ?? 0,
+      length: node && !atRoot ? node.length : 1
+    });
+  }
+  return out;
+}
+
+// src/run.ts
+function lineCol(text, offset) {
+  let line = 1;
+  let last = -1;
+  for (let i = 0; i < offset && i < text.length; i++) {
+    if (text[i] === "\n") {
+      line++;
+      last = i;
+    }
+  }
+  return { line, column: offset - last };
+}
+function validateText(text) {
+  const syntaxErrors = [];
+  parseTree2(text, syntaxErrors, { allowTrailingComma: false });
+  if (syntaxErrors.length) {
+    return syntaxErrors.map((e) => ({
+      severity: "error",
+      code: "invalid-json",
+      message: "the document is not valid JSON",
+      ...lineCol(text, e.offset)
+    }));
+  }
+  try {
+    parse2(text);
+  } catch (e) {
+    if (e instanceof TopoParseError) {
+      return [
+        { severity: "error", code: "invalid-topology", message: e.message, line: 1, column: 1 }
+      ];
+    }
+    throw e;
+  }
+  return computeOffsetDiagnostics(text).map((d) => ({
+    severity: d.severity,
+    code: d.code,
+    message: d.message,
+    ...lineCol(text, d.start)
+  }));
+}
+var ORDER = { error: 0, warning: 1, info: 2 };
+function formatHuman(file, diagnostics) {
+  if (!diagnostics.length) return `${file}: OK`;
+  const sorted = [...diagnostics].sort(
+    (a, b) => ORDER[a.severity] - ORDER[b.severity] || a.line - b.line || a.column - b.column
+  );
+  return sorted.map((d) => `${file}:${d.line}:${d.column} ${d.severity} ${d.code} ${d.message}`).join("\n");
+}
+var USAGE = `topodraft \u2014 validate TopoDraft topology files (*.topo.json / *.topo)
+
+Usage:
+  topodraft validate [--json] [--strict] <file...>
+
+Options:
+  --json     machine-readable output (one JSON object per run)
+  --strict   exit non-zero on warnings too (default: errors only)
+
+Exit codes: 0 = clean, 1 = diagnostics failed the gate, 2 = usage/IO error.`;
+function runCli(argv, io, version) {
+  if (argv.includes("--version") || argv.includes("-v")) {
+    io.stdout(version);
+    return 0;
+  }
+  if (argv[0] !== "validate" || argv.includes("--help") || argv.includes("-h")) {
+    (argv[0] === void 0 || argv.includes("--help") || argv.includes("-h") ? io.stdout : io.stderr)(USAGE);
+    return argv[0] === void 0 || argv.includes("--help") || argv.includes("-h") ? 0 : 2;
+  }
+  const rest = argv.slice(1);
+  const json = rest.includes("--json");
+  const strict = rest.includes("--strict");
+  const files = rest.filter((a) => !a.startsWith("--"));
+  const unknownFlags = rest.filter((a) => a.startsWith("--") && !["--json", "--strict"].includes(a));
+  if (unknownFlags.length || !files.length) {
+    io.stderr(unknownFlags.length ? `unknown option: ${unknownFlags[0]}
+${USAGE}` : USAGE);
+    return 2;
+  }
+  const results = [];
+  for (const file of files) {
+    try {
+      results.push({ file, diagnostics: validateText(io.readFile(file)) });
+    } catch (e) {
+      results.push({ file, diagnostics: [], error: e.message });
+    }
+  }
+  if (json) {
+    io.stdout(JSON.stringify({ results }, null, 2));
+  } else {
+    for (const r of results) {
+      io.stdout(r.error !== void 0 ? `${r.file}: cannot read (${r.error})` : formatHuman(r.file, r.diagnostics));
+    }
+  }
+  if (results.some((r) => r.error !== void 0)) return 2;
+  const failing = results.some(
+    (r) => r.diagnostics.some((d) => d.severity === "error" || strict && d.severity === "warning")
+  );
+  return failing ? 1 : 0;
+}
+
+// src/cli.ts
+var VERSION = true ? "0.1.0" : "dev";
+process.exitCode = runCli(
+  process.argv.slice(2),
+  {
+    readFile: (path) => (0, import_node_fs.readFileSync)(path, "utf8"),
+    stdout: (line) => process.stdout.write(line + "\n"),
+    stderr: (line) => process.stderr.write(line + "\n")
+  },
+  VERSION
+);