@grexx/grexxlinter 0.2.1372 → 0.2.1408

package/cli.js

@@ -14998,12 +14998,108 @@ function meetsThreshold(severity, failOn) {
 function messageKey(m) {
   return `${m.rule}|${m.path}|${m.severity}|${m.message}`;
 }
+var ANY_OF_REQUIRED = /^(.*\/anyOf)\/\d+\/required$/;
+function requireAnyKey(e) {
+  if (e.keyword !== "required") return null;
+  const m = ANY_OF_REQUIRED.exec(e.schemaPath);
+  return m ? `${m[1]}@${e.instancePath}` : null;
+}
+function collectMapState(errors) {
+  const forbidden = /* @__PURE__ */ new Set();
+  const requireAny = /* @__PURE__ */ new Map();
+  for (const e of errors) {
+    if (e.keyword === "false schema") forbidden.add(e.instancePath);
+    const key2 = requireAnyKey(e);
+    if (key2 === null) continue;
+    const g = requireAny.get(key2) ?? { instancePath: e.instancePath, fields: [], err: e };
+    g.fields.push(String(e.params.missingProperty));
+    requireAny.set(key2, g);
+  }
+  return { forbidden, requireAny, emittedRequireAny: /* @__PURE__ */ new Set() };
+}
+function pushRequireAny(e, state, ctx) {
+  const key2 = requireAnyKey(e);
+  const g = key2 === null ? null : state.requireAny.get(key2);
+  if (!g || g.fields.length < 2) return false;
+  if (!state.emittedRequireAny.has(key2)) {
+    state.emittedRequireAny.add(key2);
+    const where = describeState(ctx.schema, g.err, ctx.root, ctx.resolve);
+    const suffix = where ? ` ${where}` : "";
+    ctx.push("required-field", g.instancePath, null, `missing at least one of: ${g.fields.join(", ")}${suffix}`);
+  }
+  return true;
+}
+function pushValueError(e, loc, ctx) {
+  const p = e.params;
+  const allowed = e.keyword === "enum" ? p.allowedValues ?? [] : [p.allowedValue];
+  const actual = valueAtPointer(ctx.root, e.instancePath);
+  const want = caseOnlyMatch(actual, allowed);
+  if (want != null) {
+    ctx.push("value-case", loc.path, loc.field, `"${String(actual)}" should be "${want}" (case/format mismatch)`);
+    return;
+  }
+  const got = actual === void 0 ? "absent" : JSON.stringify(actual);
+  ctx.push("invalid-value", loc.path, loc.field, `got ${got} \u2014 ${humanize(e)}`);
+}
+function receivedType(v) {
+  if (v === null) return "null";
+  if (Array.isArray(v)) return "array";
+  return typeof v;
+}
+function pushTypeError(e, loc, ctx) {
+  const actual = valueAtPointer(ctx.root, e.instancePath);
+  let val = JSON.stringify(actual) ?? "";
+  if (val.length > 60) val = `${val.slice(0, 57)}\u2026"`;
+  const expected = String(e.params.type);
+  const withValue = actual === void 0 ? "" : ` with value ${val}`;
+  ctx.push("invalid-type", loc.path, loc.field, `expected ${expected} but received ${receivedType(actual)}${withValue}`);
+}
+function pushSchemaError(e, loc, ctx) {
+  const rule = ruleForKeyword(e.keyword);
+  let message = humanize(e);
+  if (rule === "forbidden-field" || rule === "required-field") {
+    const where = describeState(ctx.schema, e, ctx.root, ctx.resolve);
+    if (where) message += ` ${where}`;
+  }
+  ctx.push(rule, loc.path, loc.field, message);
+}
+function mapError(e, state, ctx) {
+  if (META_KEYWORDS.has(e.keyword)) return;
+  if (pushRequireAny(e, state, ctx)) return;
+  const loc = locate(e);
+  const isAdditional = e.keyword === "additionalProperties" || e.keyword === "unevaluatedProperties";
+  if (isAdditional && state.forbidden.has(loc.path)) return;
+  if (e.keyword === "enum" || e.keyword === "const") pushValueError(e, loc, ctx);
+  else if (e.keyword === "type") pushTypeError(e, loc, ctx);
+  else pushSchemaError(e, loc, ctx);
+}
+function mapAjvErrors(errors, ctx) {
+  const state = collectMapState(errors);
+  for (const e of errors) mapError(e, state, ctx);
+}
+function isSkipped(casetype, settings) {
+  if (casetype != null && settings.ignoreCasetypes.includes(casetype)) return true;
+  return settings.includeCasetypes.length > 0 && (casetype == null || !settings.includeCasetypes.includes(casetype));
+}
+function pushUncovered(push, coverage, casetype) {
+  if (!coverage || !casetype) return;
+  const n = coverage.uncoveredCount(casetype);
+  if (n > 0) push("unknown-casetype", "", casetype, `${n} rule clause(s) for "${casetype}" are behaviour-only and not checked by the schema`);
+}
+function dedupeMessages(messages) {
+  const seen = /* @__PURE__ */ new Set();
+  return messages.filter((m) => {
+    const k = messageKey(m);
+    if (seen.has(k)) return false;
+    seen.add(k);
+    return true;
+  });
+}
 function lintDocument(ctx, input) {
   const settings = normalizeSettings(ctx.settings);
   const casetype = detectCasetype(input);
+  if (isSkipped(casetype, settings)) return { file: input.file, casetype, messages: [], skipped: true, ok: true };
   const messages = [];
-  const skipped = casetype != null && settings.ignoreCasetypes.includes(casetype) || settings.includeCasetypes.length > 0 && (casetype == null || !settings.includeCasetypes.includes(casetype));
-  if (skipped) return { file: input.file, casetype, messages: [], skipped: true, ok: true };
   const push = (rule, path, field, message) => {
     const sev = severityFor(rule, settings);
     if (sev === "off") return;
@@ -15013,86 +15109,15 @@ function lintDocument(ctx, input) {
   if (!validate) {
     push("unknown-casetype", "", casetype, casetype ? `no schema for casetype "${casetype}"` : "could not determine casetype (no `_type`)");
   } else if (!validate(input.value)) {
-    const errors = validate.errors ?? [];
-    const schema = validate.schema;
-    const forbidden = /* @__PURE__ */ new Set();
-    for (const e of errors) if (e.keyword === "false schema") forbidden.add(e.instancePath);
-    const anyOfRe = /^(.*\/anyOf)\/\d+\/required$/;
-    const reqAnyGroups = /* @__PURE__ */ new Map();
-    for (const e of errors) {
-      const m = e.keyword === "required" ? anyOfRe.exec(e.schemaPath) : null;
-      if (!m) continue;
-      const key2 = `${m[1]}@${e.instancePath}`;
-      const g = reqAnyGroups.get(key2) ?? { instancePath: e.instancePath, fields: [], err: e };
-      g.fields.push(String(e.params.missingProperty));
-      reqAnyGroups.set(key2, g);
-    }
-    const emittedReqAny = /* @__PURE__ */ new Set();
-    for (const e of errors) {
-      if (META_KEYWORDS.has(e.keyword)) continue;
-      if (e.keyword === "required") {
-        const m = anyOfRe.exec(e.schemaPath);
-        const key2 = m ? `${m[1]}@${e.instancePath}` : null;
-        const g = key2 ? reqAnyGroups.get(key2) : null;
-        if (g && g.fields.length >= 2) {
-          if (!emittedReqAny.has(key2)) {
-            emittedReqAny.add(key2);
-            const state = describeState(schema, g.err, input.value, ctx.registry.resolveRef);
-            const stateSuffix = state ? ` ${state}` : "";
-            push("required-field", g.instancePath, null, `missing at least one of: ${g.fields.join(", ")}${stateSuffix}`);
-          }
-          continue;
-        }
-      }
-      const { field, path } = locate(e);
-      if ((e.keyword === "additionalProperties" || e.keyword === "unevaluatedProperties") && forbidden.has(path)) {
-        continue;
-      }
-      if (e.keyword === "enum" || e.keyword === "const") {
-        const p = e.params;
-        const allowed = e.keyword === "enum" ? p.allowedValues ?? [] : [p.allowedValue];
-        const actual = valueAtPointer(input.value, e.instancePath);
-        const want = caseOnlyMatch(actual, allowed);
-        if (want != null) {
-          push("value-case", path, field, `"${String(actual)}" should be "${want}" (case/format mismatch)`);
-          continue;
-        }
-        const got = actual === void 0 ? "absent" : JSON.stringify(actual);
-        push("invalid-value", path, field, `got ${got} \u2014 ${humanize(e)}`);
-        continue;
-      }
-      if (e.keyword === "type") {
-        const actual = valueAtPointer(input.value, e.instancePath);
-        let recv = typeof actual;
-        if (actual === null) recv = "null";
-        else if (Array.isArray(actual)) recv = "array";
-        let val = JSON.stringify(actual) ?? "";
-        if (val.length > 60) val = `${val.slice(0, 57)}\u2026"`;
-        const expected = String(e.params.type);
-        const withValue = actual === void 0 ? "" : ` with value ${val}`;
-        push("invalid-type", path, field, `expected ${expected} but received ${recv}${withValue}`);
-        continue;
-      }
-      const rule = ruleForKeyword(e.keyword);
-      let message = humanize(e);
-      if (rule === "forbidden-field" || rule === "required-field") {
-        const state = describeState(schema, e, input.value, ctx.registry.resolveRef);
-        if (state) message += ` ${state}`;
-      }
-      push(rule, path, field, message);
-    }
-  }
-  if (settings.reportUncovered && ctx.coverage && casetype) {
-    const n = ctx.coverage.uncoveredCount(casetype);
-    if (n > 0) push("unknown-casetype", "", casetype, `${n} rule clause(s) for "${casetype}" are behaviour-only and not checked by the schema`);
+    mapAjvErrors(validate.errors ?? [], {
+      push,
+      schema: validate.schema,
+      root: input.value,
+      resolve: ctx.registry.resolveRef
+    });
   }
-  const seen = /* @__PURE__ */ new Set();
-  const deduped = messages.filter((m) => {
-    const k = messageKey(m);
-    if (seen.has(k)) return false;
-    seen.add(k);
-    return true;
-  });
+  if (settings.reportUncovered) pushUncovered(push, ctx.coverage, casetype);
+  const deduped = dedupeMessages(messages);
   const ok = !deduped.some((m) => meetsThreshold(m.severity, settings.failOn));
   return { file: input.file, casetype, messages: deduped, skipped: false, ok };
 }
@@ -15127,7 +15152,7 @@ function toJSOrError(doc) {
 // src/cli.ts
 var PARALLEL_THRESHOLD = 200;
 var MAX_WORKERS = 8;
-var VERSION = true ? "0.2.1372" : "0.0.0-dev";
+var VERSION = "0.2.1408";
 function isNewer(latest, current) {
   const a = latest.split(".").map(Number);
   const b = current.split(".").map(Number);
@@ -15147,26 +15172,60 @@ function checkForUpdate(disabled) {
   return fetch("https://registry.npmjs.org/@grexx%2Fgrexxlinter/latest", { signal: ctrl.signal }).then((r) => r.ok ? r.json() : null).then((j) => j?.version && isNewer(j.version, VERSION) ? j.version : null).catch(() => null).finally(() => clearTimeout(timer));
 }
 var VALID_RULES = new Set(LINT_RULE_DESCRIPTORS.map((d) => d.id));
+function parseOffList(raw) {
+  const list = raw.split(",").map((s) => s.trim()).filter(Boolean);
+  for (const r of list) {
+    if (!VALID_RULES.has(r)) throw new Error(`--off: unknown rule "${r}" (valid: ${[...VALID_RULES].join(", ")})`);
+  }
+  return list;
+}
+var VALUE_FLAGS = /* @__PURE__ */ new Map([
+  ["--settings", (args, v) => {
+    args.settingsFile = v;
+  }],
+  ["--off", (args, v) => {
+    args.off.push(...parseOffList(v ?? ""));
+  }],
+  ["--schemas-dir", (args, v) => {
+    args.schemasDir = v;
+  }],
+  ["--fail-on", (args, v) => {
+    args.failOn = v;
+  }],
+  ["--format", (args, v) => {
+    args.format = v;
+  }],
+  ["--report", (args, v) => {
+    args.report = v;
+  }]
+]);
+var BOOL_FLAGS = /* @__PURE__ */ new Map([
+  ["--quiet", (args) => {
+    args.quiet = true;
+  }],
+  ["--errors-only", (args) => {
+    args.errorsOnly = true;
+  }],
+  ["--no-update-check", (args) => {
+    args.noUpdateCheck = true;
+  }]
+]);
 function parseArgs(argv) {
   const args = { paths: [], off: [], format: "text", quiet: false, errorsOnly: false, noUpdateCheck: false };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
-    if (a === "--settings") args.settingsFile = argv[++i];
-    else if (a === "--off") {
-      const list = (argv[++i] ?? "").split(",").map((s) => s.trim()).filter(Boolean);
-      for (const r of list) {
-        if (!VALID_RULES.has(r)) throw new Error(`--off: unknown rule "${r}" (valid: ${[...VALID_RULES].join(", ")})`);
-        args.off.push(r);
-      }
-    } else if (a === "--schemas-dir") args.schemasDir = argv[++i];
-    else if (a === "--fail-on") args.failOn = argv[++i];
-    else if (a === "--format") args.format = argv[++i];
-    else if (a === "--report") args.report = argv[++i];
-    else if (a === "--quiet") args.quiet = true;
-    else if (a === "--errors-only") args.errorsOnly = true;
-    else if (a === "--no-update-check") args.noUpdateCheck = true;
-    else if (a.startsWith("--")) throw new Error(`unknown option: ${a}`);
-    else args.paths.push(a);
+    const withValue = VALUE_FLAGS.get(a);
+    if (withValue) {
+      withValue(args, argv[++i]);
+      continue;
+    }
+    const toggle = BOOL_FLAGS.get(a);
+    if (toggle) {
+      toggle(args);
+      continue;
+    }
+    if (a.startsWith("--")) throw new Error(`unknown option: ${a}`);
+    args.paths.push(a);
   }
   if (args.report && args.report !== "rules" && args.report !== "fields") {
     throw new Error(`--report must be "rules" or "fields" (got "${args.report}")`);
@@ -15203,24 +15262,24 @@ var COLORS = { error: "\x1B[31m", warning: "\x1B[33m", info: "\x1B[36m" };
 var RESET = "\x1B[0m";
 var useColor = process.stdout.isTTY;
 var paint = (s, c) => useColor ? `${c}${s}${RESET}` : s;
-function printText(results, settings, quiet, errorsOnly) {
-  for (const r of results) {
-    if (r.skipped) continue;
-    const msgs = errorsOnly ? r.messages.filter((m) => m.severity === "error") : r.messages;
-    if (quiet && msgs.length === 0) continue;
-    const rel = r.file ? relative(process.cwd(), r.file) : "<input>";
-    const casetypeTag = r.casetype ? ` (${r.casetype})` : "";
-    const head = `${rel}${casetypeTag}`;
-    if (msgs.length === 0) {
-      if (!quiet) console.log(`${paint("ok", COLORS.info)}  ${head}`);
-      continue;
-    }
-    console.log(head);
-    for (const m of msgs) {
-      const loc = m.path || "/";
-      console.log(`  ${paint(m.severity.padEnd(7), COLORS[m.severity])} ${m.rule.padEnd(16)} ${loc}  ${m.message}`);
-    }
+function printResult(r, quiet, errorsOnly) {
+  if (r.skipped) return;
+  const msgs = errorsOnly ? r.messages.filter((m) => m.severity === "error") : r.messages;
+  if (quiet && msgs.length === 0) return;
+  const rel = r.file ? relative(process.cwd(), r.file) : "<input>";
+  const casetypeTag = r.casetype ? ` (${r.casetype})` : "";
+  const head = `${rel}${casetypeTag}`;
+  if (msgs.length === 0) {
+    if (!quiet) console.log(`${paint("ok", COLORS.info)}  ${head}`);
+    return;
   }
+  console.log(head);
+  for (const m of msgs) {
+    const loc = m.path || "/";
+    console.log(`  ${paint(m.severity.padEnd(7), COLORS[m.severity])} ${m.rule.padEnd(16)} ${loc}  ${m.message}`);
+  }
+}
+function printSummary(results, settings) {
   const s = summarize(results.filter((r) => !r.skipped));
   const skipped = results.filter((r) => r.skipped).length;
   const skippedNote = skipped ? `, ${skipped} skipped` : "";
@@ -15231,6 +15290,10 @@ function printText(results, settings, quiet, errorsOnly) {
 ${s.files} file(s)${skippedNote} \u2014 ${errorsText}, ${warningsText}, ${s.infos} info(s) [fail-on: ${settings.failOn}]`
   );
 }
+function printText(results, settings, quiet, errorsOnly) {
+  for (const r of results) printResult(r, quiet, errorsOnly);
+  printSummary(results, settings);
+}
 function printReport(results, kind, errorsOnly) {
   let msgs = results.filter((r) => !r.skipped).flatMap((r) => r.messages);
   if (errorsOnly) msgs = msgs.filter((m) => m.severity === "error");
@@ -15265,47 +15328,42 @@ function printReport(results, kind, errorsOnly) {
   }
 }
 var WORKER_FILE = fileURLToPath2(import.meta.url);
-function lintFiles(files, ctx, settings) {
-  const out = [];
-  const caseRefs = loadCaseRefs(ctx.schemasDir);
-  const parseErr = (file, message) => ({
+function parseErrorResult(file, message, settings) {
+  return {
     file,
     casetype: null,
     skipped: false,
     ok: settings.failOn === "never",
     messages: [{ severity: "error", rule: "parse-error", casetype: null, path: "", field: null, message, file }]
-  });
-  for (const file of files) {
-    const text = readFileSync2(file, "utf8");
-    if (!isLintableYaml(text)) continue;
-    let docs;
-    try {
-      docs = (0, import_yaml3.parseAllDocuments)(text);
-    } catch (e) {
-      out.push(parseErr(file, e.message));
-      continue;
-    }
-    for (const doc of docs) {
-      if (doc.errors.length > 0) {
-        out.push(parseErr(file, doc.errors[0].message));
-        continue;
-      }
-      const resolved = toJSOrError(doc);
-      if (resolved.error !== void 0) {
-        out.push(parseErr(file, resolved.error));
-        continue;
-      }
-      const input = { value: resolved.value, file };
-      const result = lintDocument({ registry: ctx.registry, coverage: ctx.coverage, settings }, input);
-      const refs = referenceFindings(input.value, file, caseRefs, settings);
-      if (refs.length) {
-        result.messages.push(...refs);
-        if (result.ok && refs.some((m) => meetsThreshold(m.severity, settings.failOn))) result.ok = false;
-      }
-      out.push(result);
-    }
+  };
+}
+function lintOneDoc(doc, file, ctx, settings, caseRefs) {
+  if (doc.errors.length > 0) return parseErrorResult(file, doc.errors[0].message, settings);
+  const resolved = toJSOrError(doc);
+  if (resolved.error !== void 0) return parseErrorResult(file, resolved.error, settings);
+  const input = { value: resolved.value, file };
+  const result = lintDocument({ registry: ctx.registry, coverage: ctx.coverage, settings }, input);
+  const refs = referenceFindings(input.value, file, caseRefs, settings);
+  if (refs.length) {
+    result.messages.push(...refs);
+    if (result.ok && refs.some((m) => meetsThreshold(m.severity, settings.failOn))) result.ok = false;
+  }
+  return result;
+}
+function lintOneFile(file, ctx, settings, caseRefs) {
+  const text = readFileSync2(file, "utf8");
+  if (!isLintableYaml(text)) return [];
+  let docs;
+  try {
+    docs = (0, import_yaml3.parseAllDocuments)(text);
+  } catch (e) {
+    return [parseErrorResult(file, e.message, settings)];
   }
-  return out;
+  return docs.map((doc) => lintOneDoc(doc, file, ctx, settings, caseRefs));
+}
+function lintFiles(files, ctx, settings) {
+  const caseRefs = loadCaseRefs(ctx.schemasDir);
+  return files.flatMap((file) => lintOneFile(file, ctx, settings, caseRefs));
 }
 async function runParallel(files, settings, schemasDir) {
   const n = Math.min(MAX_WORKERS, availableParallelism(), files.length);

package/lsp.js

@@ -23956,12 +23956,108 @@ function meetsThreshold(severity, failOn) {
 function messageKey(m) {
   return `${m.rule}|${m.path}|${m.severity}|${m.message}`;
 }
+var ANY_OF_REQUIRED = /^(.*\/anyOf)\/\d+\/required$/;
+function requireAnyKey(e) {
+  if (e.keyword !== "required") return null;
+  const m = ANY_OF_REQUIRED.exec(e.schemaPath);
+  return m ? `${m[1]}@${e.instancePath}` : null;
+}
+function collectMapState(errors) {
+  const forbidden = /* @__PURE__ */ new Set();
+  const requireAny = /* @__PURE__ */ new Map();
+  for (const e of errors) {
+    if (e.keyword === "false schema") forbidden.add(e.instancePath);
+    const key2 = requireAnyKey(e);
+    if (key2 === null) continue;
+    const g = requireAny.get(key2) ?? { instancePath: e.instancePath, fields: [], err: e };
+    g.fields.push(String(e.params.missingProperty));
+    requireAny.set(key2, g);
+  }
+  return { forbidden, requireAny, emittedRequireAny: /* @__PURE__ */ new Set() };
+}
+function pushRequireAny(e, state, ctx2) {
+  const key2 = requireAnyKey(e);
+  const g = key2 === null ? null : state.requireAny.get(key2);
+  if (!g || g.fields.length < 2) return false;
+  if (!state.emittedRequireAny.has(key2)) {
+    state.emittedRequireAny.add(key2);
+    const where = describeState(ctx2.schema, g.err, ctx2.root, ctx2.resolve);
+    const suffix = where ? ` ${where}` : "";
+    ctx2.push("required-field", g.instancePath, null, `missing at least one of: ${g.fields.join(", ")}${suffix}`);
+  }
+  return true;
+}
+function pushValueError(e, loc, ctx2) {
+  const p = e.params;
+  const allowed = e.keyword === "enum" ? p.allowedValues ?? [] : [p.allowedValue];
+  const actual = valueAtPointer(ctx2.root, e.instancePath);
+  const want = caseOnlyMatch(actual, allowed);
+  if (want != null) {
+    ctx2.push("value-case", loc.path, loc.field, `"${String(actual)}" should be "${want}" (case/format mismatch)`);
+    return;
+  }
+  const got = actual === void 0 ? "absent" : JSON.stringify(actual);
+  ctx2.push("invalid-value", loc.path, loc.field, `got ${got} \u2014 ${humanize(e)}`);
+}
+function receivedType(v) {
+  if (v === null) return "null";
+  if (Array.isArray(v)) return "array";
+  return typeof v;
+}
+function pushTypeError(e, loc, ctx2) {
+  const actual = valueAtPointer(ctx2.root, e.instancePath);
+  let val = JSON.stringify(actual) ?? "";
+  if (val.length > 60) val = `${val.slice(0, 57)}\u2026"`;
+  const expected = String(e.params.type);
+  const withValue = actual === void 0 ? "" : ` with value ${val}`;
+  ctx2.push("invalid-type", loc.path, loc.field, `expected ${expected} but received ${receivedType(actual)}${withValue}`);
+}
+function pushSchemaError(e, loc, ctx2) {
+  const rule = ruleForKeyword(e.keyword);
+  let message = humanize(e);
+  if (rule === "forbidden-field" || rule === "required-field") {
+    const where = describeState(ctx2.schema, e, ctx2.root, ctx2.resolve);
+    if (where) message += ` ${where}`;
+  }
+  ctx2.push(rule, loc.path, loc.field, message);
+}
+function mapError(e, state, ctx2) {
+  if (META_KEYWORDS.has(e.keyword)) return;
+  if (pushRequireAny(e, state, ctx2)) return;
+  const loc = locate(e);
+  const isAdditional = e.keyword === "additionalProperties" || e.keyword === "unevaluatedProperties";
+  if (isAdditional && state.forbidden.has(loc.path)) return;
+  if (e.keyword === "enum" || e.keyword === "const") pushValueError(e, loc, ctx2);
+  else if (e.keyword === "type") pushTypeError(e, loc, ctx2);
+  else pushSchemaError(e, loc, ctx2);
+}
+function mapAjvErrors(errors, ctx2) {
+  const state = collectMapState(errors);
+  for (const e of errors) mapError(e, state, ctx2);
+}
+function isSkipped(casetype, settings2) {
+  if (casetype != null && settings2.ignoreCasetypes.includes(casetype)) return true;
+  return settings2.includeCasetypes.length > 0 && (casetype == null || !settings2.includeCasetypes.includes(casetype));
+}
+function pushUncovered(push, coverage, casetype) {
+  if (!coverage || !casetype) return;
+  const n = coverage.uncoveredCount(casetype);
+  if (n > 0) push("unknown-casetype", "", casetype, `${n} rule clause(s) for "${casetype}" are behaviour-only and not checked by the schema`);
+}
+function dedupeMessages(messages) {
+  const seen = /* @__PURE__ */ new Set();
+  return messages.filter((m) => {
+    const k = messageKey(m);
+    if (seen.has(k)) return false;
+    seen.add(k);
+    return true;
+  });
+}
 function lintDocument(ctx2, input) {
   const settings2 = normalizeSettings(ctx2.settings);
   const casetype = detectCasetype(input);
+  if (isSkipped(casetype, settings2)) return { file: input.file, casetype, messages: [], skipped: true, ok: true };
   const messages = [];
-  const skipped = casetype != null && settings2.ignoreCasetypes.includes(casetype) || settings2.includeCasetypes.length > 0 && (casetype == null || !settings2.includeCasetypes.includes(casetype));
-  if (skipped) return { file: input.file, casetype, messages: [], skipped: true, ok: true };
   const push = (rule, path, field, message) => {
     const sev = severityFor(rule, settings2);
     if (sev === "off") return;
@@ -23971,86 +24067,15 @@ function lintDocument(ctx2, input) {
   if (!validate) {
     push("unknown-casetype", "", casetype, casetype ? `no schema for casetype "${casetype}"` : "could not determine casetype (no `_type`)");
   } else if (!validate(input.value)) {
-    const errors = validate.errors ?? [];
-    const schema = validate.schema;
-    const forbidden = /* @__PURE__ */ new Set();
-    for (const e of errors) if (e.keyword === "false schema") forbidden.add(e.instancePath);
-    const anyOfRe = /^(.*\/anyOf)\/\d+\/required$/;
-    const reqAnyGroups = /* @__PURE__ */ new Map();
-    for (const e of errors) {
-      const m = e.keyword === "required" ? anyOfRe.exec(e.schemaPath) : null;
-      if (!m) continue;
-      const key2 = `${m[1]}@${e.instancePath}`;
-      const g = reqAnyGroups.get(key2) ?? { instancePath: e.instancePath, fields: [], err: e };
-      g.fields.push(String(e.params.missingProperty));
-      reqAnyGroups.set(key2, g);
-    }
-    const emittedReqAny = /* @__PURE__ */ new Set();
-    for (const e of errors) {
-      if (META_KEYWORDS.has(e.keyword)) continue;
-      if (e.keyword === "required") {
-        const m = anyOfRe.exec(e.schemaPath);
-        const key2 = m ? `${m[1]}@${e.instancePath}` : null;
-        const g = key2 ? reqAnyGroups.get(key2) : null;
-        if (g && g.fields.length >= 2) {
-          if (!emittedReqAny.has(key2)) {
-            emittedReqAny.add(key2);
-            const state = describeState(schema, g.err, input.value, ctx2.registry.resolveRef);
-            const stateSuffix = state ? ` ${state}` : "";
-            push("required-field", g.instancePath, null, `missing at least one of: ${g.fields.join(", ")}${stateSuffix}`);
-          }
-          continue;
-        }
-      }
-      const { field, path } = locate(e);
-      if ((e.keyword === "additionalProperties" || e.keyword === "unevaluatedProperties") && forbidden.has(path)) {
-        continue;
-      }
-      if (e.keyword === "enum" || e.keyword === "const") {
-        const p = e.params;
-        const allowed = e.keyword === "enum" ? p.allowedValues ?? [] : [p.allowedValue];
-        const actual = valueAtPointer(input.value, e.instancePath);
-        const want = caseOnlyMatch(actual, allowed);
-        if (want != null) {
-          push("value-case", path, field, `"${String(actual)}" should be "${want}" (case/format mismatch)`);
-          continue;
-        }
-        const got = actual === void 0 ? "absent" : JSON.stringify(actual);
-        push("invalid-value", path, field, `got ${got} \u2014 ${humanize(e)}`);
-        continue;
-      }
-      if (e.keyword === "type") {
-        const actual = valueAtPointer(input.value, e.instancePath);
-        let recv = typeof actual;
-        if (actual === null) recv = "null";
-        else if (Array.isArray(actual)) recv = "array";
-        let val = JSON.stringify(actual) ?? "";
-        if (val.length > 60) val = `${val.slice(0, 57)}\u2026"`;
-        const expected = String(e.params.type);
-        const withValue = actual === void 0 ? "" : ` with value ${val}`;
-        push("invalid-type", path, field, `expected ${expected} but received ${recv}${withValue}`);
-        continue;
-      }
-      const rule = ruleForKeyword(e.keyword);
-      let message = humanize(e);
-      if (rule === "forbidden-field" || rule === "required-field") {
-        const state = describeState(schema, e, input.value, ctx2.registry.resolveRef);
-        if (state) message += ` ${state}`;
-      }
-      push(rule, path, field, message);
-    }
-  }
-  if (settings2.reportUncovered && ctx2.coverage && casetype) {
-    const n = ctx2.coverage.uncoveredCount(casetype);
-    if (n > 0) push("unknown-casetype", "", casetype, `${n} rule clause(s) for "${casetype}" are behaviour-only and not checked by the schema`);
+    mapAjvErrors(validate.errors ?? [], {
+      push,
+      schema: validate.schema,
+      root: input.value,
+      resolve: ctx2.registry.resolveRef
+    });
   }
-  const seen = /* @__PURE__ */ new Set();
-  const deduped = messages.filter((m) => {
-    const k = messageKey(m);
-    if (seen.has(k)) return false;
-    seen.add(k);
-    return true;
-  });
+  if (settings2.reportUncovered) pushUncovered(push, ctx2.coverage, casetype);
+  const deduped = dedupeMessages(messages);
   const ok = !deduped.some((m) => meetsThreshold(m.severity, settings2.failOn));
   return { file: input.file, casetype, messages: deduped, skipped: false, ok };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grexx/grexxlinter",
-  "version": "0.2.1372",
+  "version": "0.2.1408",
   "description": "Lint Grexx Studio casetype YAML against the studio JSON Schemas.",
   "type": "module",
   "bin": {