@grexx/grexxlinter 0.2.1318 → 0.2.1408

package/cli.js

@@ -14547,8 +14547,7 @@ function buildCoverageIndex(doc) {
   return {
     clauseCovered(casetype, field, modality, when) {
       if (!casetype || !field) return null;
-      const v = map.get(key(casetype, field, modality, when));
-      return v === void 0 ? null : v;
+      return map.get(key(casetype, field, modality, when)) ?? null;
     },
     uncoveredCount: (casetype) => uncovered.get(casetype) ?? 0
   };
@@ -14999,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;
@@ -15014,82 +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);
-            push("required-field", g.instancePath, null, `missing at least one of: ${g.fields.join(", ")}${state ? ` ${state}` : ""}`);
-          }
-          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);
-        const recv = actual === null ? "null" : Array.isArray(actual) ? "array" : typeof actual;
-        let val = JSON.stringify(actual) ?? "";
-        if (val.length > 60) val = `${val.slice(0, 57)}\u2026"`;
-        const expected = String(e.params.type);
-        push("invalid-type", path, field, `expected ${expected} but received ${recv}${actual === void 0 ? "" : ` with value ${val}`}`);
-        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 };
 }
@@ -15124,7 +15152,7 @@ function toJSOrError(doc) {
 // src/cli.ts
 var PARALLEL_THRESHOLD = 200;
 var MAX_WORKERS = 8;
-var VERSION = true ? "0.2.1318" : "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);
@@ -15144,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}")`);
@@ -15195,34 +15257,43 @@ function discover(paths, exclude) {
   for (const p of paths) walk(p);
   return files;
 }
+var KEY_SEP = String.fromCodePoint(0);
 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 head = `${rel}${r.casetype ? ` (${r.casetype})` : ""}`;
-    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` : "";
+  const errorsText = paint(`${s.errors} error(s)`, COLORS.error);
+  const warningsText = paint(`${s.warnings} warning(s)`, COLORS.warning);
   console.log(
     `
-${s.files} file(s)${skipped ? `, ${skipped} skipped` : ""} \u2014 ${paint(`${s.errors} error(s)`, COLORS.error)}, ${paint(`${s.warnings} warning(s)`, COLORS.warning)}, ${s.infos} info(s) [fail-on: ${settings.failOn}]`
+${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");
@@ -15243,7 +15314,7 @@ function printReport(results, kind, errorsOnly) {
   }
   const by = /* @__PURE__ */ new Map();
   for (const m of msgs) {
-    const key2 = `${m.casetype ?? "?"}\0${m.rule}\0${m.severity}\0${m.message}`;
+    const key2 = [m.casetype ?? "?", m.rule, m.severity, m.message].join(KEY_SEP);
     const e = by.get(key2) ?? { count: 0, casetype: m.casetype ?? "?", severity: m.severity, message: m.message };
     e.count++;
     by.set(key2, e);
@@ -15257,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);
@@ -15363,5 +15429,5 @@ async function main() {
   }
   process.exit(summarize(results.filter((r) => !r.skipped)).exitCode);
 }
-if (isMainThread) void main();
+if (isMainThread) await main();
 else runWorker();

package/lsp.js

@@ -23616,8 +23616,7 @@ function buildCoverageIndex(doc) {
   return {
     clauseCovered(casetype, field, modality, when) {
       if (!casetype || !field) return null;
-      const v = map.get(key(casetype, field, modality, when));
-      return v === void 0 ? null : v;
+      return map.get(key(casetype, field, modality, when)) ?? null;
     },
     uncoveredCount: (casetype) => uncovered.get(casetype) ?? 0
   };
@@ -23957,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;
@@ -23972,82 +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);
-            push("required-field", g.instancePath, null, `missing at least one of: ${g.fields.join(", ")}${state ? ` ${state}` : ""}`);
-          }
-          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);
-        const recv = actual === null ? "null" : Array.isArray(actual) ? "array" : typeof actual;
-        let val = JSON.stringify(actual) ?? "";
-        if (val.length > 60) val = `${val.slice(0, 57)}\u2026"`;
-        const expected = String(e.params.type);
-        push("invalid-type", path, field, `expected ${expected} but received ${recv}${actual === void 0 ? "" : ` with value ${val}`}`);
-        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.1318",
+  "version": "0.2.1408",
   "description": "Lint Grexx Studio casetype YAML against the studio JSON Schemas.",
   "type": "module",
   "bin": {

package/schemas/widget.schema.json

@@ -250,6 +250,280 @@
   "title": "widget",
   "type": "object",
   "allOf": [
+    {
+      "$comment": "Shape of the legacy options blob for grids — the only structure it has, since widget.options is declared `additionalProperties: true`. Closed at every level: an unknown key is an additional-field finding. The key set and the types are the union observed over 1275 grid widgets (def-yamls-142 plus three real projects); where the stored spelling and the studio's mapper disagree, both are declared, because both are live.",
+      "if": {
+        "properties": {
+          "widgetType": {
+            "enum": [
+              "grid",
+              "grid-v2"
+            ]
+          }
+        },
+        "required": [
+          "widgetType"
+        ]
+      },
+      "then": {
+        "properties": {
+          "options": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+              "type": {
+                "type": "string"
+              },
+              "usesCases": {
+                "type": "boolean"
+              },
+              "dataset": {
+                "type": "string"
+              },
+              "extraclasses": {
+                "$comment": "Extra CSS classes on the widget wrapper. No editor writes it; it rides through from the legacy designer.",
+                "type": "string"
+              },
+              "grid": {
+                "type": "object",
+                "additionalProperties": false,
+                "properties": {
+                  "showHeader": {
+                    "type": "boolean"
+                  },
+                  "title": {
+                    "type": "string"
+                  },
+                  "showToolbar": {
+                    "type": "boolean"
+                  },
+                  "showSimpleSearch": {
+                    "type": "boolean"
+                  },
+                  "showAdvancedSearch": {
+                    "type": "boolean"
+                  },
+                  "showLinenumbers": {
+                    "type": "boolean"
+                  },
+                  "showColumnHeaders": {
+                    "type": "boolean"
+                  },
+                  "showColumnSelector": {
+                    "type": "boolean"
+                  },
+                  "showFooter": {
+                    "type": "boolean"
+                  },
+                  "noFullCount": {
+                    "type": "boolean"
+                  },
+                  "selectColumn": {
+                    "type": "boolean"
+                  },
+                  "autoHeight": {
+                    "type": "boolean"
+                  },
+                  "saveSearch": {
+                    "type": "string"
+                  },
+                  "orderColumn": {
+                    "type": "string"
+                  },
+                  "height": {
+                    "$comment": "Every stored value is a string (\"640\"); the studio's mapper writes a number on edit.",
+                    "type": [
+                      "string",
+                      "number"
+                    ]
+                  },
+                  "pagination": {
+                    "type": "object",
+                    "additionalProperties": false,
+                    "properties": {
+                      "rowsPerPage": {
+                        "type": [
+                          "number",
+                          "string"
+                        ]
+                      },
+                      "inifiteScroll": {
+                        "$comment": "Misspelled in the atalanta runtime that reads it — this is the wire format.",
+                        "type": "boolean"
+                      }
+                    }
+                  },
+                  "gridAggregationRowType": {
+                    "$comment": "Mirror of the first-class gridAggregationRowType; stored as an empty array on all but one of 475 occurrences, so both spellings are allowed.",
+                    "type": [
+                      "string",
+                      "array"
+                    ]
+                  },
+                  "gridAggregationRowPosition": {
+                    "$comment": "Mirror of the first-class gridAggregationRowPosition; stored as an empty array, as above.",
+                    "type": [
+                      "string",
+                      "array"
+                    ]
+                  }
+                }
+              },
+              "row": {
+                "type": "object",
+                "additionalProperties": false,
+                "properties": {
+                  "clickHandler": {
+                    "type": "string"
+                  },
+                  "clickHandlerColumnCase": {
+                    "type": "string"
+                  },
+                  "rowHeight": {
+                    "type": [
+                      "string",
+                      "number"
+                    ]
+                  },
+                  "viewToOpen": {
+                    "$comment": "Only read when clickHandler is viewHandler; the studio drops both keys when it is not.",
+                    "type": "string"
+                  },
+                  "customViewModalClasses": {
+                    "type": "string"
+                  }
+                }
+              },
+              "subgrid": {
+                "type": "object",
+                "additionalProperties": false,
+                "properties": {
+                  "enabled": {
+                    "type": "boolean"
+                  },
+                  "height": {
+                    "type": [
+                      "string",
+                      "number"
+                    ]
+                  }
+                }
+              },
+              "columns": {
+                "$comment": "Keyed by the dataset column's atalanta case id. On a case-converted grid the entry degrades to a caseId pointer at the gridColumn; on a grid that was never converted it keeps the full inline column settings instead, and those 2798 legacy entries are what the types below are read off. `size` stays untyped: it is a nested map whose own key set has no second source to check against.",
+                "type": "object",
+                "additionalProperties": {
+                  "type": "object",
+                  "additionalProperties": false,
+                  "properties": {
+                    "caseId": {
+                      "type": "string"
+                    },
+                    "name": {
+                      "type": "string"
+                    },
+                    "column": {
+                      "type": "string"
+                    },
+                    "title": {
+                      "type": "string"
+                    },
+                    "hidden": {
+                      "type": "boolean"
+                    },
+                    "hideable": {
+                      "type": "boolean"
+                    },
+                    "searchable": {
+                      "type": "boolean"
+                    },
+                    "sortable": {
+                      "type": "boolean"
+                    },
+                    "resizable": {
+                      "type": "boolean"
+                    },
+                    "wordwrap": {
+                      "type": "boolean"
+                    },
+                    "valueAsRowClass": {
+                      "type": "boolean"
+                    },
+                    "render": {
+                      "type": "string"
+                    },
+                    "order": {
+                      "type": [
+                        "integer",
+                        "string"
+                      ]
+                    },
+                    "clickHandler": {
+                      "type": "string"
+                    },
+                    "clickHandlerColumnCase": {
+                      "type": "string"
+                    },
+                    "aggregationOperation": {
+                      "$comment": "Written here by the studio's mapper, but absent from every stored legacy entry — no observed value to type it from, so the key is accepted untyped."
+                    },
+                    "size": {
+                      "type": "object"
+                    }
+                  }
+                }
+              },
+              "activities": {
+                "$comment": "Keyed by slot — addActivityId / editActivity / finishActivity / multiNN. Unlike columns these keep their full legacy field set alongside the caseId pointer, so every key here is observed and typed.",
+                "type": "object",
+                "additionalProperties": {
+                  "type": "object",
+                  "additionalProperties": false,
+                  "properties": {
+                    "caseId": {
+                      "type": "string"
+                    },
+                    "activity": {
+                      "type": "string"
+                    },
+                    "enabled": {
+                      "type": "boolean"
+                    },
+                    "title": {
+                      "type": "string"
+                    },
+                    "useActivityTitle": {
+                      "type": "boolean"
+                    },
+                    "icon": {
+                      "type": "string"
+                    },
+                    "type": {
+                      "type": "string"
+                    },
+                    "checkRights": {
+                      "type": "string"
+                    },
+                    "whenDoneRefreshType": {
+                      "type": "string"
+                    },
+                    "breaker": {
+                      "type": "boolean"
+                    },
+                    "order": {
+                      "type": [
+                        "integer",
+                        "string"
+                      ]
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
     {
       "if": {
         "properties": {