sysml-validate 0.16.0 → 0.17.0

package/out/main.js

@@ -58649,6 +58649,18 @@ var DIAGNOSTIC_MESSAGES = {
   // `first a then b;` and the `then` occurrence shorthand in a part), so the
   // message names the construct it means rather than "action language".
   SEM011_ACTION_ONLY_CONSTRUCT: (construct, clause, owner) => `${construct} may only be declared in the body of an action definition or usage (OMG SysML v2 Part 1 \xA7${clause}), not in ${owner}.`,
+  // REQ-392 — issue #150. A `rep … language "sysml"` body is a legal representation
+  // of the element it annotates (OMG KerML §7.4.3), so the two faults are "this is
+  // not SysML" and "this is not THIS element". The parser's own wording is carried
+  // through verbatim, because it names the token the reader has to go and fix.
+  SYN076_EMBEDDED_REPRESENTATION_SYNTAX: (language, detail) => `This representation declares language "${language}", so its body must be valid ${language}: ${detail}`,
+  SEM012_REPRESENTATION_WRONG_KIND: (expected, actual) => `A textual representation must represent the element it annotates. This body represents '${actual}', but it annotates '${expected}'.`,
+  // REQ-392 — The body is resolved in the represented element's own context, so an
+  // unresolvable name there is the same defect it would be in ordinary code. It is
+  // reported under its own code so a team can tune representations separately.
+  RES020_REPRESENTATION_UNRESOLVED: (name, language) => `'${name}' cannot be resolved from here, so this ${language} representation is not a valid representation of the element it annotates.`,
+  RES020_REPRESENTATION_PATH_SEGMENT: (segment, owner, language) => `Feature path segment '${segment}' does not exist on '${owner}', so this ${language} representation is not a valid representation of the element it annotates.`,
+  SEM012_REPRESENTATION_WRONG_NAME: (expected, actual) => `A textual representation must represent the element it annotates. This body represents '${actual}', but it annotates '${expected}'.`,
   RES016_LIBRARY_SHADOWING: (name) => `'${name}' shadows a standard-library element of the same name; the library symbol is hidden in this scope.`,
   // issue #183 — KerML namespace distinguishability (validateNamespaceDistinguishability).
   // Owned siblings sharing a name/short name (or an alias clashing with an owned
@@ -59596,6 +59608,274 @@ function isNamespaceOnlyDecl(node) {
   return node.isDef === true;
 }
 
+// ../language-server/out/src/services/comment-body.js
+function sourceOf(node) {
+  return node.$cstNode?.root.fullText;
+}
+function cleanBlockBodyLines(raw, rawOffset) {
+  let cut = raw.length - raw.trimStart().length;
+  let body = raw.slice(cut).trimEnd();
+  if (body.startsWith("/*")) {
+    body = body.slice(2);
+    cut += 2;
+  }
+  if (body.endsWith("*/"))
+    body = body.slice(0, -2);
+  const lines = [];
+  let cursor = cut;
+  for (const rawLine of body.split("\n")) {
+    const gutter = /^\s*\*+ ?/u.exec(rawLine);
+    const skip = gutter ? gutter[0].length : 0;
+    lines.push({
+      text: rawLine.slice(skip).replace(/\s+$/u, ""),
+      offset: rawOffset + cursor + skip
+    });
+    cursor += rawLine.length + 1;
+  }
+  while (lines.length > 0 && lines[0].text.trim() === "")
+    lines.shift();
+  while (lines.length > 0 && lines[lines.length - 1].text.trim() === "")
+    lines.pop();
+  if (lines.length > 0) {
+    const lead = lines[0].text.length - lines[0].text.trimStart().length;
+    if (lead > 0)
+      lines[0] = { text: lines[0].text.slice(lead), offset: lines[0].offset + lead };
+  }
+  return lines;
+}
+function cleanBlockBody(inner) {
+  return cleanBlockBodyLines(inner, 0).map((line) => line.text).join("\n");
+}
+function docCommentBody(node) {
+  const raw = node.doc;
+  if (typeof raw !== "string")
+    return void 0;
+  const start = raw.indexOf("/*");
+  const end = raw.lastIndexOf("*/");
+  if (start < 0 || end < start)
+    return void 0;
+  const body = cleanBlockBody(raw.slice(start, end + 2));
+  return body.length > 0 ? body : void 0;
+}
+function trailingBlockBodySpan(node) {
+  const cst = node.$cstNode;
+  const text = sourceOf(node);
+  if (!cst || text === void 0)
+    return void 0;
+  const rest = text.slice(cst.end);
+  const open = rest.indexOf("/*");
+  if (open < 0)
+    return void 0;
+  if (rest.slice(0, open).trim() !== "")
+    return void 0;
+  const close = rest.indexOf("*/", open + 2);
+  if (close < 0)
+    return void 0;
+  const raw = rest.slice(open, close + 2);
+  const lines = cleanBlockBodyLines(raw, cst.end + open);
+  const body = lines.map((line) => line.text).join("\n");
+  if (body.length === 0)
+    return void 0;
+  return { text: body, lines, open: cst.end + open, close: cst.end + close + 2 };
+}
+function trailingBlockBody(node) {
+  return trailingBlockBodySpan(node)?.text;
+}
+function bodyOffsetAt(span, line, character) {
+  const entry = Number.isInteger(line) ? span.lines[line] : void 0;
+  if (!entry)
+    return span.open;
+  const column = Number.isFinite(character) ? character : 0;
+  return entry.offset + Math.max(0, Math.min(column, entry.text.length));
+}
+
+// ../language-server/out/src/services/embedded-representation.js
+var EMBEDDED_LANGUAGES = /* @__PURE__ */ new Set(["sysml", "kerml"]);
+var EXPRESSION_VALUED_OWNERS = /* @__PURE__ */ new Set([
+  "AssertConstraintStmt",
+  "AssumeConstraintStmt",
+  "RequireConstraintStmt",
+  "ConstraintDecl",
+  "InvShorthand",
+  "CalcDecl",
+  "ExpressionDecl"
+]);
+function isEmbeddedLanguage(raw) {
+  if (typeof raw !== "string")
+    return false;
+  return EMBEDDED_LANGUAGES.has(raw.replace(/^"|"$/gu, "").trim().toLowerCase());
+}
+function bareName(node) {
+  const name = node?.name;
+  return typeof name === "string" && name.length > 0 ? name.replace(/^'|'$/gu, "") : void 0;
+}
+function kindOf(node) {
+  const decl = /^([A-Z][a-z]+)Decl$/.exec(node.$type);
+  if (decl) {
+    const base = decl[1].toLowerCase();
+    return node.isDef ? `${base} def` : base;
+  }
+  switch (node.$type) {
+    case "Package":
+      return "package";
+    case "InvShorthand":
+      return "inv";
+    case "AssertConstraintStmt":
+      return "assert constraint";
+    case "AssumeConstraintStmt":
+      return "assume constraint";
+    case "RequireConstraintStmt":
+      return "require constraint";
+    default:
+      return node.$type;
+  }
+}
+function hasErrors(result) {
+  return result.lexerErrors.length > 0 || result.parserErrors.length > 0;
+}
+function describeParserError(error) {
+  const image = error.token?.image ?? "";
+  const expecting = /Expecting token of type '([^']+)'/u.exec(error.message ?? "");
+  if (image === "") {
+    return expecting ? `the body ends while '${expecting[1]}' is still expected.` : "the body ends before it is complete.";
+  }
+  if (error.name === "NotAllInputParsedException") {
+    return `'${image}' is left over after the representation is already complete.`;
+  }
+  if (expecting)
+    return `expected '${expecting[1]}' but found '${image}'.`;
+  return `unexpected '${image}'.`;
+}
+function describeLexerError(error) {
+  const character = /unexpected character: ->(.*?)<-/u.exec(error.message ?? "");
+  return character ? `unexpected character '${character[1]}'.` : error.message ?? "the body cannot be read.";
+}
+function failureOf(result, span) {
+  const endLine = Math.max(0, span.lines.length - 1);
+  const end = { line: endLine, character: span.lines[endLine]?.text.length ?? 0 };
+  const lexical = result.lexerErrors[0];
+  const syntactic = result.parserErrors[0];
+  if (lexical && Number.isFinite(lexical.line)) {
+    return {
+      line: lexical.line - 1,
+      character: Math.max(0, (Number.isFinite(lexical.column) ? lexical.column : 1) - 1),
+      message: describeLexerError(lexical)
+    };
+  }
+  if (syntactic) {
+    const token = syntactic.token;
+    const message = describeParserError(syntactic);
+    if (Number.isFinite(token?.startLine) && Number.isFinite(token?.startColumn)) {
+      return { line: token.startLine - 1, character: token.startColumn - 1, message };
+    }
+    return { ...end, message };
+  }
+  return { ...end, message: lexical ? describeLexerError(lexical) : "the body is not valid SysML." };
+}
+function conformance(parsed, owner) {
+  if (!parsed || !owner || owner.$type === "Document")
+    return { status: "ok" };
+  const sameKind = parsed.$type === owner.$type && Boolean(parsed.isDef) === Boolean(owner.isDef);
+  if (!sameKind) {
+    return { status: "mismatch", mismatch: { reason: "kind", expected: kindOf(owner), actual: kindOf(parsed) } };
+  }
+  const expected = bareName(owner);
+  const actual = bareName(parsed);
+  if (expected && actual && expected !== actual) {
+    return { status: "mismatch", mismatch: { reason: "name", expected, actual } };
+  }
+  return { status: "ok" };
+}
+function nodesOf(root3) {
+  return [root3, ...ast_utils_exports.streamAllContents(root3)];
+}
+function declaredNames(root3) {
+  const names = /* @__PURE__ */ new Set();
+  for (const node of nodesOf(root3)) {
+    const name = node.name;
+    if (typeof name === "string" && name.length > 0)
+      names.add(name.replace(/^'|'$/gu, ""));
+  }
+  return names;
+}
+function graftInto(fragment, owner) {
+  const mutable = fragment;
+  mutable.$container = owner;
+  mutable.$containerProperty = "members";
+}
+function firstSegment(refText) {
+  return (refText.split("::")[0] ?? refText).replace(/^'|'$/gu, "").trim();
+}
+function unresolvedReferences(fragment, owner) {
+  graftInto(fragment, owner);
+  const own = declaredNames(fragment);
+  const out = [];
+  for (const node of nodesOf(fragment)) {
+    for (const [property3, value] of Object.entries(node)) {
+      if (property3.startsWith("$"))
+        continue;
+      for (const candidate of Array.isArray(value) ? value : [value]) {
+        if (!isReference(candidate))
+          continue;
+        const reference = candidate;
+        const refText = reference.$refText;
+        if (!refText || own.has(firstSegment(refText)))
+          continue;
+        let resolved;
+        try {
+          resolved = reference.ref;
+        } catch {
+          return [];
+        }
+        if (resolved)
+          continue;
+        const range = reference.$refNode?.range;
+        if (!range)
+          continue;
+        out.push({
+          refText,
+          line: range.start.line,
+          character: range.start.character,
+          length: Math.max(1, range.end.character - range.start.character)
+        });
+      }
+    }
+  }
+  return out;
+}
+function evaluateRepresentation(parser, rep) {
+  if (!isEmbeddedLanguage(rep.language))
+    return void 0;
+  const span = trailingBlockBodySpan(rep);
+  if (!span)
+    return void 0;
+  const owner = rep.$container;
+  const context = owner && owner.$type !== "Document" ? owner : void 0;
+  const declaration = parser.parse(span.text, { rule: "NamespaceElement" });
+  if (!hasErrors(declaration)) {
+    return {
+      span,
+      verdict: conformance(declaration.value, owner),
+      unresolved: context ? unresolvedReferences(declaration.value, context) : [],
+      fragment: declaration.value,
+      tier: "declaration"
+    };
+  }
+  if (owner && EXPRESSION_VALUED_OWNERS.has(owner.$type)) {
+    const expression = parser.parse(span.text, { rule: "Expr" });
+    if (!hasErrors(expression)) {
+      return {
+        span,
+        verdict: { status: "ok" },
+        unresolved: context ? unresolvedReferences(expression.value, context) : [],
+        fragment: expression.value,
+        tier: "expression"
+      };
+    }
+  }
+  return { span, verdict: { status: "unparsed", failure: failureOf(declaration, span) }, unresolved: [] };
+}
+
 // ../language-server/out/src/services/conformance.js
 var SPECIALIZATION_KINDS2 = /* @__PURE__ */ new Set([
   ":>",
@@ -60034,7 +60314,14 @@ var SysmlValidator = class _SysmlValidator {
   langiumDocuments;
   astNodeLocator;
   featurePaths;
+  // REQ-396 — One SysmlValidator instance is registered against BOTH the SysML and
+  // the KerML services (sysml-module.ts), so the parser used to read an embedded
+  // representation is looked up from the document being validated rather than
+  // captured here. The two share one grammar today; this keeps that from becoming
+  // load-bearing.
+  serviceRegistry;
   constructor(services) {
+    this.serviceRegistry = services.shared.ServiceRegistry;
     this.indexManager = services.shared.workspace.IndexManager;
     this.langiumDocuments = services.shared.workspace.LangiumDocuments;
     this.astNodeLocator = services.workspace.AstNodeLocator;
@@ -60050,23 +60337,38 @@ var SysmlValidator = class _SysmlValidator {
   // Langium linker cannot diagnose a missing intermediate feature. Resolve the
   // chain here and underline only the first invalid segment.
   checkPathExpr(node, accept) {
+    const fault = this.featurePathFault(node);
+    if (!fault)
+      return;
+    accept(severity("RES001", "error"), DIAGNOSTIC_MESSAGES.RES001_FEATURE_PATH_SEGMENT(fault.segment, fault.owner), {
+      node,
+      range: fault.range,
+      code: "RES001",
+      data: { featurePathSegment: true }
+    });
+  }
+  // REQ-317, REQ-396 — The one place that decides whether a written feature path
+  // has a provably absent segment. Extracted so an embedded representation body is
+  // judged by exactly this rule (issue #150 review): a body is grafted onto the
+  // element it represents and is therefore unreachable from the document walk that
+  // dispatches `checkPathExpr`, so without a shared decision the two would drift
+  // and a body would quietly escape a diagnostic the surrounding model receives.
+  featurePathFault(node) {
     let declaration = node.$container;
     while (declaration && !isPartDecl(declaration))
       declaration = declaration.$container;
     const modifiers2 = declaration?.modifiers ?? [];
     if (!declaration || !modifiers2.includes("ref"))
-      return;
+      return void 0;
     const resolution = this.featurePaths.resolve(node);
     if (resolution.unresolvedIndex === void 0)
-      return;
+      return void 0;
     const invalid = resolution.segments[resolution.unresolvedIndex];
-    const owner = resolution.unresolvedIndex > 0 ? resolution.segments[resolution.unresolvedIndex - 1].text : "the current scope";
-    accept(severity("RES001", "error"), DIAGNOSTIC_MESSAGES.RES001_FEATURE_PATH_SEGMENT(invalid.text, owner), {
-      node,
-      range: invalid.cst.range,
-      code: "RES001",
-      data: { featurePathSegment: true }
-    });
+    return {
+      segment: invalid.text,
+      owner: resolution.unresolvedIndex > 0 ? resolution.segments[resolution.unresolvedIndex - 1].text : "the current scope",
+      range: invalid.cst.range
+    };
   }
   // REQ-389 — Namespace qualification versus feature chaining in every written path
   // issue #213 — RES019: `::` binds tighter than `.`. Each dot-separated link of
@@ -60297,6 +60599,7 @@ var SysmlValidator = class _SysmlValidator {
     this.checkConnectorForms(node, accept);
     this.checkActionStartSuccessions(node, accept);
     this.checkAnnotationForms(node, accept);
+    this.checkEmbeddedRepresentations(node, accept);
     this.checkLanguageDisjointness(node, accept);
     this.checkKermlWellFormedness(node, accept);
     this.checkFilterExpressions(node, accept);
@@ -60637,6 +60940,132 @@ ${baseIndent}}`;
       }
     }
   }
+  // REQ-396 — SYN076/SEM012 embedded textual representations (issue #150).
+  // A `rep … language "sysml"` (or `"kerml"`, matched case-insensitively) is not
+  // opaque content: OMG KerML §7.4.3 requires its body to be a legal representation
+  // of the element it annotates. So the body is processed by the comment-body rules,
+  // parsed, and compared against that element:
+  //   SYN076 — the body is not valid SysML, reported ON the offending character
+  //            inside the body rather than on the `rep` keyword.
+  //   SEM012 — the body parses but represents a different element (wrong kind, or
+  //            the right kind under a different name).
+  // Every other language stays opaque and is never parsed — an `alf`, `ocl` or
+  // `yaml` body is content, and the vendored OMG corpus holds only those.
+  checkEmbeddedRepresentations(node, accept) {
+    const doc = ast_utils_exports.getDocument(node);
+    if (!doc?.textDocument)
+      return;
+    let parser;
+    for (const child of ast_utils_exports.streamAllContents(node)) {
+      if (child.$type !== "RepStmt")
+        continue;
+      if (!isEmbeddedLanguage(child.language))
+        continue;
+      parser ??= this.serviceRegistry.getServices(doc.uri).parser.LangiumParser;
+      const evaluated = evaluateRepresentation(parser, child);
+      if (!evaluated)
+        continue;
+      const { span, verdict } = evaluated;
+      const language = String(child.language ?? "").replace(/^"|"$/gu, "");
+      if (verdict.status === "unparsed") {
+        const { line, character, message } = verdict.failure;
+        const anchor = bodyOffsetAt(span, line, character);
+        const after = bodyOffsetAt(span, line, character + 1);
+        const from = after > anchor ? anchor : bodyOffsetAt(span, line, Math.max(0, character - 1));
+        accept(severity("SYN076", "error"), DIAGNOSTIC_MESSAGES.SYN076_EMBEDDED_REPRESENTATION_SYNTAX(language, message), {
+          node: child,
+          range: {
+            start: doc.textDocument.positionAt(from),
+            end: doc.textDocument.positionAt(Math.max(after, anchor))
+          },
+          code: "SYN076"
+        });
+        continue;
+      }
+      for (const reference of evaluated.unresolved) {
+        accept(severity("RES020", "warning"), DIAGNOSTIC_MESSAGES.RES020_REPRESENTATION_UNRESOLVED(reference.refText, language), {
+          node: child,
+          range: {
+            start: doc.textDocument.positionAt(bodyOffsetAt(span, reference.line, reference.character)),
+            end: doc.textDocument.positionAt(bodyOffsetAt(span, reference.line, reference.character + reference.length))
+          },
+          code: "RES020"
+        });
+      }
+      if (evaluated.fragment) {
+        this.checkEmbeddedDialect(child, evaluated.fragment, language, span, doc, accept);
+        this.checkEmbeddedFeaturePaths(child, evaluated.fragment, language, span, doc, accept);
+      }
+      if (verdict.status === "ok")
+        continue;
+      const { reason, expected, actual } = verdict.mismatch;
+      const owner = child.$container;
+      accept(severity("SEM012", "warning"), reason === "kind" ? DIAGNOSTIC_MESSAGES.SEM012_REPRESENTATION_WRONG_KIND(expected, actual) : DIAGNOSTIC_MESSAGES.SEM012_REPRESENTATION_WRONG_NAME(expected, actual), {
+        node: child,
+        range: {
+          start: doc.textDocument.positionAt(bodyOffsetAt(span, 0, 0)),
+          end: doc.textDocument.positionAt(bodyOffsetAt(span, 0, span.lines[0]?.text.length ?? 0))
+        },
+        code: "SEM012",
+        relatedInformation: owner ? [relatedInfo(owner, "The element this representation annotates.")].filter((info) => info !== void 0) : void 0
+      });
+    }
+  }
+  // REQ-396 — SYN100/SYN101 inside a representation body (issue #150 review).
+  // The normative rule is that the body is legal in the language the representation
+  // NAMES, which is not the language of the file it sits in: a `.sysml` file may
+  // carry a `language "kerml"` representation, and its body may then use no
+  // SysML-only construct. `checkLanguageDisjointness` answers a different question
+  // — what may this FILE contain — from the host URI, so the same tables are read
+  // here against the declared language instead.
+  checkEmbeddedDialect(rep, fragment, language, span, doc, accept) {
+    const dialect = language.trim().toLowerCase();
+    const isKerml = dialect === "kerml";
+    const forbidden = isKerml ? SYSML_ONLY_TYPES : KERML_ONLY_TYPES;
+    const code = isKerml ? "SYN100" : "SYN101";
+    for (const node of [fragment, ...ast_utils_exports.streamAllContents(fragment)]) {
+      if (!forbidden.has(node.$type))
+        continue;
+      const range = node.$cstNode?.range;
+      if (!range)
+        continue;
+      accept(severity(code, "error"), isKerml ? `'${declKeyword(node)}' is a SysML construct and is not available in a "${language}" representation.` : `'${declKeyword(node)}' is a KerML-only construct \u2014 use the SysML form in a "${language}" representation.`, {
+        node: rep,
+        range: this.bodyRange(span, doc, range),
+        code
+      });
+    }
+  }
+  // REQ-396 — RES020 for a written feature path with a provably absent segment
+  // (issue #150 review). `checkPathExpr` is registered as a node-level check, so
+  // Langium dispatches it by walking the document AST and never reaches the grafted
+  // fragment. The decision itself is shared with it through `featurePathFault`, so
+  // a body is held to the same rule as the model around it rather than a parallel
+  // one that could drift; only the code differs, keeping every fault found IN a
+  // representation body under the one severity a team can tune.
+  checkEmbeddedFeaturePaths(rep, fragment, language, span, doc, accept) {
+    for (const node of [fragment, ...ast_utils_exports.streamAllContents(fragment)]) {
+      if (!this.featurePaths.isPathExpr(node))
+        continue;
+      const fault = this.featurePathFault(node);
+      if (!fault)
+        continue;
+      accept(severity("RES020", "warning"), DIAGNOSTIC_MESSAGES.RES020_REPRESENTATION_PATH_SEGMENT(fault.segment, fault.owner, language), {
+        node: rep,
+        range: this.bodyRange(span, doc, fault.range),
+        code: "RES020"
+      });
+    }
+  }
+  // REQ-396 — A range inside a parsed body, expressed in document coordinates.
+  // Fragment CST positions are line/character within the PROCESSED body, which is
+  // exactly what the span's line table converts.
+  bodyRange(span, doc, range) {
+    return {
+      start: doc.textDocument.positionAt(bodyOffsetAt(span, range.start.line, range.start.character)),
+      end: doc.textDocument.positionAt(bodyOffsetAt(span, range.end.line, range.end.character))
+    };
+  }
   // REQ-311 — SYN050/051 connector syntax, with a specific message in place of
   // the grammar's generic parse error:
   //   SYN050 — `connect a with b;` (use `connect a to b;`).
@@ -63511,52 +63940,6 @@ function outlineGroupForType(astType) {
   return CATEGORY_TO_OUTLINE_GROUP[categoryForType(astType)] ?? "structure";
 }
 
-// ../language-server/out/src/services/comment-body.js
-function sourceOf(node) {
-  return node.$cstNode?.root.fullText;
-}
-function cleanBlockBody(inner) {
-  let body = inner.trim();
-  if (body.startsWith("/*"))
-    body = body.slice(2);
-  if (body.endsWith("*/"))
-    body = body.slice(0, -2);
-  const lines = body.split("\n").map((line) => line.replace(/^\s*\*+ ?/u, "").replace(/\s+$/u, ""));
-  while (lines.length > 0 && lines[0].trim() === "")
-    lines.shift();
-  while (lines.length > 0 && lines[lines.length - 1].trim() === "")
-    lines.pop();
-  return lines.join("\n").trim();
-}
-function docCommentBody(node) {
-  const raw = node.doc;
-  if (typeof raw !== "string")
-    return void 0;
-  const start = raw.indexOf("/*");
-  const end = raw.lastIndexOf("*/");
-  if (start < 0 || end < start)
-    return void 0;
-  const body = cleanBlockBody(raw.slice(start, end + 2));
-  return body.length > 0 ? body : void 0;
-}
-function trailingBlockBody(node) {
-  const cst = node.$cstNode;
-  const text = sourceOf(node);
-  if (!cst || text === void 0)
-    return void 0;
-  const rest = text.slice(cst.end);
-  const open = rest.indexOf("/*");
-  if (open < 0)
-    return void 0;
-  if (rest.slice(0, open).trim() !== "")
-    return void 0;
-  const close = rest.indexOf("*/", open + 2);
-  if (close < 0)
-    return void 0;
-  const body = cleanBlockBody(rest.slice(open, close + 2));
-  return body.length > 0 ? body : void 0;
-}
-
 // ../language-server/out/src/services/document-symbol-provider.js
 var SPECIALIZATION_KINDS4 = /* @__PURE__ */ new Set([":>", "specializes"]);
 var REDEFINITION_KINDS = /* @__PURE__ */ new Set([":>>", "redefines"]);
@@ -71093,7 +71476,7 @@ async function runValidation(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.16.0" : "dev";
+var VERSION2 = true ? "0.17.0" : "dev";
 async function main(argv) {
   const command = parseArgs(argv);
   if (command.kind === "help") {