@amritk/lint 0.6.1 → 0.7.0

package/dist/index.d.ts

@@ -140,8 +140,9 @@ export type IFixResult = {
 };
 /**
  * Lints a document and applies the supplied `fixers` repeatedly until the
- * document stops changing (or {@link MAX_FIX_PASSES} is reached), then re-lints
- * so `remaining` reflects the fixed document. A one-call convenience over
+ * document stops changing (or {@link MAX_FIX_PASSES} is reached). `remaining`
+ * reflects the fixed document: the converging pass already linted it, so only
+ * a run that hit the cap lints once more. A one-call convenience over
  * {@link lintDocumentWithResult} + `createFixPlugin`. With no `fixers` this is a
  * no-op that just returns the findings.
  */

package/dist/index.js

@@ -83,10 +83,12 @@ const fixDocument = async (input, options = {}) => {
   let converged = false;
   const applied = [];
   const seen = /* @__PURE__ */ new Set();
+  let convergedDiagnostics;
   for (let pass = 0; pass < MAX_FIX_PASSES; pass++) {
     const result = await runLint(current, ruleset, { ...lintOptions, plugins: [plugin] });
     if (result.output === void 0 || result.output === current) {
       converged = true;
+      convergedDiagnostics = result.diagnostics;
       break;
     }
     current = result.output;
@@ -102,7 +104,7 @@ const fixDocument = async (input, options = {}) => {
       }
     }
   }
-  const remaining = (await runLint(current, ruleset, lintOptions)).diagnostics;
+  const remaining = convergedDiagnostics ?? (await runLint(current, ruleset, lintOptions)).diagnostics;
   return { output: current, fixed: current !== input, remaining, applied, converged, passes };
 };
 export {

package/dist/parsers/edit-model.js

@@ -1,4 +1,4 @@
-import { isAlias, isMap, isScalar, isSeq, parseDocument } from "@amritk/yaml";
+import { isMap, isScalar, isSeq, keyText, parseDocument } from "@amritk/yaml";
 import { applyEdits, findNodeAtLocation, modify, parseTree } from "jsonc-parser";
 const splice = (text, start, end, replacement) => text.slice(0, start) + replacement + text.slice(end);
 const lineStart = (text, offset) => {
@@ -20,17 +20,7 @@ const detectEol = (text) => {
   const i = text.indexOf("\n");
   return i > 0 && text.charCodeAt(i - 1) === 13 ? "\r\n" : "\n";
 };
-const keyName = (key) => {
-  if (isScalar(key)) {
-    const v = key.value;
-    return typeof v === "string" ? v : v === null ? "null" : String(v);
-  }
-  if (isAlias(key))
-    return `*${key.source}`;
-  if (isMap(key) || isSeq(key))
-    return "";
-  return String(key);
-};
+const seqIndex = (segment) => typeof segment === "number" ? segment : /^(?:0|[1-9]\d*)$/.test(segment) ? Number(segment) : -1;
 const yamlNodeAt = (root, path) => {
   let current = root ?? void 0;
   for (const segment of path) {
@@ -38,10 +28,10 @@ const yamlNodeAt = (root, path) => {
       return void 0;
     if (isMap(current)) {
       const target = String(segment);
-      const pair = current.items.findLast((item) => keyName(item.key) === target);
+      const pair = current.items.findLast((item) => keyText(item.key) === target);
       current = pair?.value ?? void 0;
     } else if (isSeq(current)) {
-      current = current.items[Number(segment)];
+      current = current.items[seqIndex(segment)];
     } else {
       return void 0;
     }
@@ -53,7 +43,7 @@ const yamlPairAt = (root, path) => {
   if (!parent || !isMap(parent))
     return {};
   const last = String(path[path.length - 1]);
-  const pair = parent.items.findLast((item) => keyName(item.key) === last);
+  const pair = parent.items.findLast((item) => keyText(item.key) === last);
   if (!pair)
     return {};
   return { key: pair.key, ...pair.value ? { value: pair.value } : {} };
@@ -133,7 +123,7 @@ const applyYamlOp = (text, op) => {
       if (!parent || !isMap(parent))
         return text;
       const last = String(op.path[op.path.length - 1]);
-      const index = parent.items.findLastIndex((item) => keyName(item.key) === last);
+      const index = parent.items.findLastIndex((item) => keyText(item.key) === last);
       if (index === -1)
         return text;
       const pair = parent.items[index];
@@ -190,7 +180,7 @@ const applyYamlOp = (text, op) => {
       }
       if (!isMap(parent))
         return text;
-      if (parent.items.some((item) => keyName(item.key) === op.key))
+      if (parent.items.some((item) => keyText(item.key) === op.key))
         return text;
       const pair = `${yamlInsertKey(op.key)}: ${yamlInsertValue(op.value)}`;
       if (text.charCodeAt(parent.start) === 123) {

package/dist/parsers/json.js

@@ -1,4 +1,4 @@
-import { findNodeAtLocation, getNodeValue, parseTree, printParseErrorCode } from "jsonc-parser";
+import { getNodeValue, parseTree, printParseErrorCode } from "jsonc-parser";
 import { findExcessiveNesting, MAX_NESTING_DEPTH } from "./depth.js";
 import { createLineMap } from "./lines.js";
 import { DiagnosticSeverity } from "./types.js";
@@ -35,7 +35,7 @@ const parseJson = (source) => {
       return void 0;
     const p = path.slice();
     while (true) {
-      const node = findNodeAtLocation(root, p);
+      const node = findNode(root, p);
       if (node) {
         return {
           range: {
@@ -51,6 +51,25 @@ const parseJson = (source) => {
   };
   return { data, diagnostics, getLocationForJsonPath };
 };
+const ARRAY_INDEX = /^(?:0|[1-9]\d*)$/;
+const findNode = (root, path) => {
+  let node = root;
+  for (const segment of path) {
+    if (node === void 0)
+      return void 0;
+    if (node.type === "object") {
+      const key = String(segment);
+      const property = node.children?.find((child) => child.children?.length === 2 && child.children[0]?.value === key);
+      node = property?.children?.[1];
+    } else if (node.type === "array") {
+      const text = String(segment);
+      node = ARRAY_INDEX.test(text) ? node.children?.[Number(text)] : void 0;
+    } else {
+      return void 0;
+    }
+  }
+  return node;
+};
 export {
   parseJson
 };

package/dist/parsers/lines.d.ts

@@ -9,5 +9,10 @@ export type LineMap = {
 /**
  * Builds a {@link LineMap} for `source`. The line-start offsets are precomputed
  * once so each `positionAt` lookup is a binary search rather than a re-scan.
+ *
+ * A line ends at CR LF, a lone CR, or a lone LF — YAML 1.2 §5.4's
+ * `b-break ::= CR LF | CR | LF`, which is also where JSON's scanner breaks lines.
+ * Counting LF alone put every position in a CR-only file on line 0 while the
+ * parser (and `@amritk/yaml`'s `lineCounter`) put it on its real line.
  */
 export declare const createLineMap: (source: string) => LineMap;

package/dist/parsers/lines.js

@@ -1,9 +1,21 @@
 const createLineMap = (source) => {
   const length = source.length;
   const lineStarts = [0];
-  for (let i = 0; i < source.length; i++) {
-    if (source.charCodeAt(i) === 10)
-      lineStarts.push(i + 1);
+  let nl = source.indexOf("\n");
+  let cr = source.indexOf("\r");
+  while (nl !== -1 || cr !== -1) {
+    if (cr !== -1 && (nl === -1 || cr < nl)) {
+      if (source.charCodeAt(cr + 1) === 10) {
+        lineStarts.push(cr + 2);
+        nl = source.indexOf("\n", cr + 2);
+      } else {
+        lineStarts.push(cr + 1);
+      }
+      cr = source.indexOf("\r", cr + 1);
+    } else {
+      lineStarts.push(nl + 1);
+      nl = source.indexOf("\n", nl + 1);
+    }
   }
   const positionAt = (offset) => {
     const clamped = Math.max(0, Math.min(offset, length));

package/dist/parsers/yaml-locator.d.ts

@@ -0,0 +1,56 @@
+import { type YamlDocument } from '@amritk/yaml';
+import type { LineMap } from './lines.js';
+import type { ILocation, JsonPath } from './types.js';
+/**
+ * Knobs for tests. `maxVisits` replaces {@link MAX_LOOKUP_VISITS} so the budget
+ * fallback can be reached with a small document, and `stats.visits` accumulates
+ * the work every lookup charged, so a test can bound a lookup's cost without
+ * timing it.
+ */
+export type YamlLocatorOptions = {
+    maxVisits?: number;
+    stats?: {
+        visits: number;
+    };
+};
+/**
+ * Builds the path-to-position lookup for a parsed YAML stream, resolving each
+ * path on demand instead of indexing every node up front.
+ *
+ * Indexing eagerly meant copying a path array, building a string key, and
+ * running two line-map searches for every node of the document — about two
+ * thirds of lint's parse time on a large spec — while a lint run only ever asks
+ * for the handful of paths that carry findings. A lookup now walks the tree from
+ * the root along the path, which is O(depth).
+ *
+ * The answers are the eager index's, including its quirks, because rulesets and
+ * fixers were written against them:
+ *
+ * - Segments match by text: `0` and `'0'` both name item 0 of a sequence and a
+ *   `"0"` key of a map, the way the index's string keys did.
+ * - An alias keeps its own range, and a path beneath it descends into the
+ *   anchored node.
+ * - A duplicated key resolves to the last occurrence — the index's last write.
+ *   Because the index was keyed by path text, *every* occurrence of the key
+ *   contributed its subtree, so a path that exists only under an earlier
+ *   duplicate still resolves there. That is why a lookup tracks a list of
+ *   candidate nodes per segment rather than a single node: the answer is the
+ *   last candidate at the full path.
+ * - A key brought in by `<<` resolves to the node `toJS` takes it from (see
+ *   {@link createMergeResolver}): explicit keys win over merged ones, an earlier
+ *   merge (or an earlier item of a merge list) wins over a later one, and a
+ *   merge source contributes the keys of its own projection — its explicit keys
+ *   ahead of anything *it* merges. A merged key only lands on a path nothing
+ *   else claimed. The eager index differed here: it walked a merge source's
+ *   pairs in order, so a nested `<<` written first claimed keys the source
+ *   itself overrides, and a finding landed on a value the data does not hold.
+ * - A key written with no value (`key:`) has no position of its own, so the key
+ *   is absent and `closest` falls back past it.
+ * - In a multi-document stream every path starts with the document index, and
+ *   the stream itself (the empty path) has no position.
+ *
+ * `closest` returns the deepest prefix that resolves, which is what popping
+ * segments off the path until the index had it found: every prefix of an indexed
+ * path was itself indexed.
+ */
+export declare const createYamlLocator: (docs: readonly YamlDocument[], lineMap: LineMap, options?: YamlLocatorOptions) => ((path: JsonPath, closest?: boolean) => ILocation | undefined);

package/dist/parsers/yaml-locator.js

@@ -0,0 +1,122 @@
+import { isAlias, isMap, isSeq } from "@amritk/yaml";
+import { createMergeResolver } from "./yaml-merge-key.js";
+const MAX_LOOKUP_VISITS = 1e5;
+const seqIndex = (segment, length) => {
+  const index = Number(segment);
+  return Number.isInteger(index) && index >= 0 && index < length && String(index) === segment ? index : -1;
+};
+const identityOf = (node) => isAlias(node) ? node.target ?? node : node;
+const dedupeCandidates = (nodes) => {
+  const last = /* @__PURE__ */ new Map();
+  for (let i = 0; i < nodes.length; i++)
+    last.set(identityOf(nodes[i]), i);
+  if (last.size === nodes.length)
+    return nodes;
+  const kept = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    const identity = identityOf(node);
+    if (!seen.has(identity)) {
+      seen.add(identity);
+      kept.push(node);
+    } else if (last.get(identity) === i) {
+      kept.push(node);
+    }
+  }
+  return kept;
+};
+const createYamlLocator = (docs, lineMap, options = {}) => {
+  const multiDocument = docs.length > 1;
+  const maxVisits = options.maxVisits ?? MAX_LOOKUP_VISITS;
+  const budget = { left: maxVisits };
+  const merges = createMergeResolver(budget);
+  const childrenOf = (visits, segment) => {
+    const children = [];
+    for (const visit of visits) {
+      if (budget.left-- <= 0)
+        return void 0;
+      const node = isAlias(visit) ? visit.target : visit;
+      if (node == null)
+        continue;
+      if (isMap(node)) {
+        const explicit = merges.tableOf(node).explicit.get(segment);
+        if (explicit) {
+          budget.left -= explicit.length;
+          for (const value of explicit)
+            children.push(value);
+        } else if (children.length === 0) {
+          const merged = merges.mergedValueOf(node, segment);
+          if (merged)
+            children.push(merged);
+        }
+      } else if (isSeq(node)) {
+        const index = seqIndex(segment, node.items.length);
+        const item = index === -1 ? void 0 : node.items[index];
+        if (item !== void 0)
+          children.push(item);
+      }
+    }
+    if (budget.left <= 0)
+      return void 0;
+    return children.length > 1 ? dedupeCandidates(children) : children;
+  };
+  const descend = (root, path, depth, closest) => {
+    let node = root;
+    for (; depth < path.length; depth++) {
+      const target = isAlias(node) ? node.target : node;
+      const segment = String(path[depth]);
+      let child;
+      if (target != null && isMap(target))
+        child = merges.projectedValueOf(target, segment);
+      else if (target != null && isSeq(target))
+        child = target.items[seqIndex(segment, target.items.length)];
+      if (child == null)
+        return closest ? node : void 0;
+      node = child;
+    }
+    return node;
+  };
+  const locate = (path, closest) => {
+    let root;
+    let depth = 0;
+    if (multiDocument) {
+      const first = path[0];
+      if (first === void 0)
+        return void 0;
+      const index = seqIndex(String(first), docs.length);
+      root = index === -1 ? null : docs[index]?.contents ?? null;
+      depth = 1;
+    } else {
+      root = docs[0]?.contents ?? null;
+    }
+    if (root == null)
+      return void 0;
+    const start = depth;
+    let visits = [root];
+    for (; depth < path.length; depth++) {
+      const children = childrenOf(visits, String(path[depth]));
+      if (children === void 0)
+        return descend(root, path, start, closest);
+      if (children.length === 0) {
+        if (!closest)
+          return void 0;
+        break;
+      }
+      visits = children;
+    }
+    return visits[visits.length - 1];
+  };
+  return (path, closest = false) => {
+    budget.left = maxVisits;
+    const node = locate(path, closest);
+    if (options.stats)
+      options.stats.visits += maxVisits - budget.left;
+    if (node === void 0)
+      return void 0;
+    return { range: { start: lineMap.positionAt(node.start), end: lineMap.positionAt(node.end) } };
+  };
+};
+export {
+  createYamlLocator
+};

package/dist/parsers/yaml-merge-key.d.ts

@@ -0,0 +1,58 @@
+import { type YamlMap, type YamlNode, type YamlPair } from '@amritk/yaml';
+/**
+ * True when a pair is a `<<` merge key, whose value folds into the parent map
+ * instead of becoming a key of its own. The parser runs with `merge: true`, so
+ * `toJS` never projects a `<<` key — which is why both the position lookup and
+ * the non-finite scan route these pairs to their merge handling rather than
+ * treating `<<` as a path segment.
+ */
+export declare const isMergePair: (pair: YamlPair) => boolean;
+/**
+ * What one map holds, gathered the first time anything asks about it: the
+ * explicit pairs' values grouped by key text (in source order, so duplicates
+ * keep their order), the `<<` values in source order, and the answers already
+ * worked out for merged keys and for the full key list.
+ */
+export type KeyTable = {
+    explicit: Map<string, YamlNode[]>;
+    merges: (YamlNode | null)[];
+    merged: Map<string, YamlNode | null>;
+    keys: string[] | undefined;
+};
+/**
+ * Answers "which node does `toJS` project this key of this map from?" for maps
+ * that use `<<`, shared by the position lookup and the non-finite scan so both
+ * agree with the data.
+ *
+ * The rule is `toJsValue`/`applyMerge` in `@amritk/yaml`: a map's object is
+ * built pair by pair, an explicit key overwrites whatever is there (so the last
+ * duplicate wins, and it beats a merged key wherever it is written), and a `<<`
+ * pair copies in every key of its source's *finished* object that the map does
+ * not hold yet (so an earlier merge, or an earlier item of a merge list, wins).
+ * The source's object was itself built by the same rule first, which is the part
+ * a walk over the source's pairs in order gets wrong: in `{<<: *b, a: 1}` the
+ * nested merge is written first, but the source's own `a` is what it projects.
+ * A merge source that is not a map or a list of maps (a scalar, a `!!set`, an
+ * `!!omap`) projects to something with no own keys and contributes nothing.
+ *
+ * One quirk is kept from the eager position index this replaced: a key written
+ * with no value (`key:`) has no node to point at, so it is treated as absent —
+ * it neither answers nor shadows — rather than as the `null` `toJS` gives it.
+ *
+ * Answers are memoised per map and key. The same anchor merged into a thousand
+ * maps, or a merge chain reached by a thousand aliases, is then scanned once,
+ * not once per map per lookup. `meter.left` is decremented for every merge
+ * source examined on a cache miss so a caller with a work budget can charge the
+ * scanning to it; the scan always runs to completion, so a cached answer is
+ * never a partial one.
+ */
+export declare const createMergeResolver: (meter?: {
+    left: number;
+}) => {
+    tableOf: (map: YamlMap) => KeyTable;
+    projectedValueOf: (map: YamlMap, key: string) => YamlNode | null;
+    mergedValueOf: (map: YamlMap, key: string) => YamlNode | null;
+    keysOf: (map: YamlMap) => readonly string[];
+};
+/** The shared merge-key resolver {@link createMergeResolver} builds. */
+export type MergeResolver = ReturnType<typeof createMergeResolver>;

package/dist/parsers/yaml-merge-key.js

@@ -0,0 +1,104 @@
+import { isAlias, isMap, isPair, isScalar, isSeq, keyText } from "@amritk/yaml";
+const isMergePair = (pair) => isScalar(pair.key) && pair.key.source === "<<";
+const createMergeResolver = (meter = { left: Number.POSITIVE_INFINITY }) => {
+  const tables = /* @__PURE__ */ new Map();
+  const tableOf = (map) => {
+    const cached = tables.get(map);
+    if (cached)
+      return cached;
+    const table = { explicit: /* @__PURE__ */ new Map(), merges: [], merged: /* @__PURE__ */ new Map(), keys: void 0 };
+    for (const pair of map.items) {
+      if (!isPair(pair))
+        continue;
+      if (isMergePair(pair)) {
+        table.merges.push(pair.value);
+        continue;
+      }
+      if (pair.value == null)
+        continue;
+      const key = keyText(pair.key);
+      const values = table.explicit.get(key);
+      if (values)
+        values.push(pair.value);
+      else
+        table.explicit.set(key, [pair.value]);
+    }
+    tables.set(map, table);
+    return table;
+  };
+  const eachSource = (node, visit) => {
+    meter.left--;
+    const target = node != null && isAlias(node) ? node.target : node;
+    if (target == null)
+      return null;
+    if (isSeq(target)) {
+      if (target.tag === "omap")
+        return null;
+      for (const item of target.items) {
+        const found = eachSource(item, visit);
+        if (found !== null)
+          return found;
+      }
+      return null;
+    }
+    if (!isMap(target) || target.tag === "set")
+      return null;
+    return visit(target);
+  };
+  const mergedValueOf = (map, key) => {
+    const table = tableOf(map);
+    if (table.merges.length === 0)
+      return null;
+    const cached = table.merged.get(key);
+    if (cached !== void 0)
+      return cached;
+    table.merged.set(key, null);
+    let found = null;
+    for (const merge of table.merges) {
+      found = eachSource(merge, (source) => projectedValueOf(source, key));
+      if (found !== null)
+        break;
+    }
+    table.merged.set(key, found);
+    return found;
+  };
+  const projectedValueOf = (map, key) => {
+    const explicit = tableOf(map).explicit.get(key);
+    if (explicit)
+      return explicit[explicit.length - 1];
+    return mergedValueOf(map, key);
+  };
+  const keysOf = (map) => {
+    const table = tableOf(map);
+    if (table.keys)
+      return table.keys;
+    const keys = [];
+    table.keys = keys;
+    const seen = /* @__PURE__ */ new Set();
+    const add = (key) => {
+      if (seen.has(key))
+        return;
+      seen.add(key);
+      keys.push(key);
+    };
+    for (const pair of map.items) {
+      if (!isPair(pair))
+        continue;
+      if (isMergePair(pair)) {
+        eachSource(pair.value, (source) => {
+          for (const key of keysOf(source))
+            add(key);
+          return null;
+        });
+      } else if (pair.value != null) {
+        add(keyText(pair.key));
+      }
+    }
+    return keys;
+  };
+  return { tableOf, projectedValueOf, mergedValueOf, keysOf };
+};
+export {
+  createMergeResolver,
+  isMergePair
+};

package/dist/parsers/yaml-non-finite.d.ts

@@ -0,0 +1,22 @@
+import { type YamlNode, type YamlScalar } from '@amritk/yaml';
+/**
+ * Calls `report` once for every scalar value in a document that projects to a
+ * non-finite number — `.nan`, `.inf`, `-.inf` under the core schema — in the
+ * order a depth-first walk of the data reaches them.
+ *
+ * `JSON.stringify` silently rewrites those values to `null`, which is what the
+ * `incompatibleValues` option exists to catch. This used to ride along with the
+ * eager position index; the index is on demand now, so the check gets its own
+ * walk, and only when the option is on.
+ *
+ * The walk covers what the projection can hold: map values, sequence items, the
+ * collection an alias names, and the keys a `<<` merge brings in — skipping a
+ * merged key an explicit key (or an earlier merge) already claimed, and taking
+ * each merged key from where the source's own projection takes it, since `toJS`
+ * drops every other value. Keys themselves are not checked; they project to
+ * strings. A collection is walked once however many aliases reach it and a
+ * value is reported once however many merges bring it in, so this is linear in
+ * the document even for the alias-heavy "billion laughs" shape, and a value
+ * written once is reported once.
+ */
+export declare const reportNonFinite: (root: YamlNode | null, report: (node: YamlScalar) => void) => void;

package/dist/parsers/yaml-non-finite.js

@@ -0,0 +1,77 @@
+import { isAlias, isMap, isPair, isScalar, isSeq, keyText } from "@amritk/yaml";
+import { createMergeResolver, isMergePair } from "./yaml-merge-key.js";
+const reportNonFinite = (root, report) => {
+  const seen = /* @__PURE__ */ new Set();
+  let merges;
+  const visitMerge = (node, claimed, sources) => {
+    const target = node != null && isAlias(node) ? node.target : node;
+    if (target == null || sources.has(target))
+      return;
+    sources.add(target);
+    if (isSeq(target)) {
+      if (target.tag === "omap")
+        return;
+      for (const item of target.items)
+        visitMerge(item, claimed, sources);
+      return;
+    }
+    if (!isMap(target) || target.tag === "set")
+      return;
+    merges ??= createMergeResolver();
+    for (const key of merges.keysOf(target)) {
+      if (claimed.has(key))
+        continue;
+      claimed.add(key);
+      visit(merges.projectedValueOf(target, key));
+    }
+  };
+  const visit = (node) => {
+    if (node == null)
+      return;
+    if (isScalar(node)) {
+      const value = node.value;
+      if (typeof value === "number" && !Number.isFinite(value) && !seen.has(node)) {
+        seen.add(node);
+        report(node);
+      }
+      return;
+    }
+    const target = isAlias(node) ? node.target : node;
+    if (target == null || seen.has(target))
+      return;
+    if (isSeq(target)) {
+      seen.add(target);
+      for (const item of target.items)
+        visit(item);
+      return;
+    }
+    if (!isMap(target))
+      return;
+    seen.add(target);
+    let hasMerge = false;
+    for (const pair of target.items) {
+      if (!isPair(pair))
+        continue;
+      if (isMergePair(pair))
+        hasMerge = true;
+      else
+        visit(pair.value);
+    }
+    if (!hasMerge)
+      return;
+    const claimed = /* @__PURE__ */ new Set();
+    for (const pair of target.items) {
+      if (isPair(pair) && !isMergePair(pair) && pair.value != null)
+        claimed.add(keyText(pair.key));
+    }
+    const sources = /* @__PURE__ */ new Set();
+    for (const pair of target.items) {
+      if (isPair(pair) && isMergePair(pair))
+        visitMerge(pair.value, claimed, sources);
+    }
+  };
+  visit(root);
+};
+export {
+  reportNonFinite
+};

package/dist/parsers/yaml.js

@@ -1,35 +1,8 @@
-import { isAlias, isMap, isPair, isScalar, isSeq, parseAllDocuments } from "@amritk/yaml";
+import { parseAllDocuments } from "@amritk/yaml";
 import { createLineMap } from "./lines.js";
 import { DiagnosticSeverity } from "./types.js";
-const pathKey = (path) => path.map((segment) => typeof segment === "number" ? `[${segment}]` : `.${segment}`).join("");
-const serializeComplexKey = (node) => {
-  if (isSeq(node)) {
-    return node.items.length === 0 ? "[]" : `[ ${node.items.map(flowText).join(", ")} ]`;
-  }
-  if (isMap(node)) {
-    const pairs = node.items.filter(isPair).map((pair) => `${flowText(pair.key)}: ${pair.value ? flowText(pair.value) : "null"}`);
-    return pairs.length === 0 ? "{}" : `{ ${pairs.join(", ")} }`;
-  }
-  return flowText(node);
-};
-const flowText = (node) => {
-  if (isScalar(node)) {
-    const v = node.value;
-    return typeof v === "string" ? v : v === null ? "null" : String(v);
-  }
-  if (isAlias(node))
-    return node.target ? flowText(node.target) : `*${node.source}`;
-  return serializeComplexKey(node);
-};
-const keyToString = (key) => {
-  if (isScalar(key)) {
-    const v = key.value;
-    return typeof v === "string" ? v : v === null ? "" : String(v);
-  }
-  if (isAlias(key))
-    return key.target ? keyToString(key.target) : `*${key.source}`;
-  return serializeComplexKey(key);
-};
+import { createYamlLocator } from "./yaml-locator.js";
+import { reportNonFinite } from "./yaml-non-finite.js";
 const parseYaml = (source, options = {}) => {
   const lineMap = createLineMap(source);
   const duplicateKeys = options.duplicateKeys;
@@ -38,7 +11,6 @@ const parseYaml = (source, options = {}) => {
   const incompatibleValues = options.incompatibleValues;
   const incompatSeverity = typeof incompatibleValues === "number" ? incompatibleValues : void 0;
   const docs = parseAllDocuments(source, { uniqueKeys: !dedupe });
-  const index = /* @__PURE__ */ new Map();
   const diagnostics = [];
   const pushError = (severity, message, start, end, code) => {
     diagnostics.push({
@@ -48,105 +20,50 @@ const parseYaml = (source, options = {}) => {
       range: { start: lineMap.positionAt(start), end: lineMap.positionAt(end) }
     });
   };
-  const rangeOf = (node) => ({
-    start: lineMap.positionAt(node.start),
-    end: lineMap.positionAt(node.end)
-  });
-  let budget = Math.max(1e5, source.length * 100);
-  const isMergePair = (pair) => isScalar(pair.key) && pair.key.source === "<<";
-  const walkMerge = (node, path) => {
-    const target = node != null && isAlias(node) ? node.target : node;
-    if (target == null)
-      return;
-    if (isSeq(target)) {
-      for (const item of target.items)
-        walkMerge(item, path);
-      return;
-    }
-    if (!isMap(target))
-      return;
-    for (const item of target.items) {
-      if (!isPair(item))
-        continue;
-      if (isMergePair(item)) {
-        walkMerge(item.value, path);
-        continue;
-      }
-      const childPath = [...path, keyToString(item.key)];
-      if (!index.has(pathKey(childPath)))
-        walk(item.value, childPath);
-    }
-  };
-  const walk = (node, path) => {
-    if (node == null || budget-- <= 0)
-      return;
-    index.set(pathKey(path), rangeOf(node));
-    if (isScalar(node)) {
-      const value = node.value;
-      if (incompatSeverity !== void 0 && typeof value === "number" && !Number.isFinite(value)) {
-        pushError(incompatSeverity, `Value ${String(value)} cannot be represented in JSON and will serialize to null.`, node.start, node.end, "INCOMPATIBLE_VALUE");
-      }
-      return;
-    }
-    const target = isAlias(node) ? node.target : node;
-    if (target == null)
+  const checkIncompatible = (doc) => {
+    if (incompatSeverity === void 0)
       return;
-    if (isMap(target)) {
-      const merges = [];
-      for (const item of target.items) {
-        if (!isPair(item))
-          continue;
-        if (isMergePair(item)) {
-          merges.push(item.value);
-          continue;
-        }
-        walk(item.value, [...path, keyToString(item.key)]);
-      }
-      for (const merge of merges)
-        walkMerge(merge, path);
-    } else if (isSeq(target)) {
-      target.items.forEach((item, i) => {
-        walk(item, [...path, i]);
-      });
-    }
+    reportNonFinite(doc.contents, (node) => {
+      pushError(incompatSeverity, `Value ${String(node.value)} cannot be represented in JSON and will serialize to null.`, node.start, node.end, "INCOMPATIBLE_VALUE");
+    });
   };
   const collectProblems = (doc) => {
     for (const err of doc.errors) {
       const severity = err.code === "DUPLICATE_KEY" ? dupSeverity : DiagnosticSeverity.Error;
-      pushError(severity, err.message, err.start, err.end);
+      pushError(severity, err.message, err.start, err.end, err.code);
     }
     for (const warn of doc.warnings) {
-      pushError(DiagnosticSeverity.Warning, warn.message, warn.start, warn.end);
+      pushError(DiagnosticSeverity.Warning, warn.message, warn.start, warn.end, warn.code);
+    }
+  };
+  const project = (doc) => {
+    try {
+      return doc.toJS();
+    } catch (error) {
+      const at = doc.contents?.start ?? 0;
+      const message = error instanceof Error ? error.message : String(error);
+      pushError(DiagnosticSeverity.Error, message, at, at, "RESOURCE_EXHAUSTION");
+      return void 0;
     }
   };
   let data;
   if (docs.length > 1) {
-    data = docs.map((doc, i) => {
-      walk(doc.contents, [i]);
+    data = docs.map((doc) => {
+      checkIncompatible(doc);
       collectProblems(doc);
-      return doc.toJS();
+      return project(doc);
     });
   } else {
     const doc = docs[0];
     if (doc) {
-      walk(doc.contents, []);
+      checkIncompatible(doc);
       collectProblems(doc);
-      data = doc.toJS();
+      data = project(doc);
     } else {
       data = null;
     }
   }
-  const getLocationForJsonPath = (path, closest = false) => {
-    const p = path.slice();
-    while (true) {
-      const range = index.get(pathKey(p));
-      if (range)
-        return { range };
-      if (!closest || p.length === 0)
-        return void 0;
-      p.pop();
-    }
-  };
+  const getLocationForJsonPath = createYamlLocator(docs, lineMap);
   return { data, diagnostics, getLocationForJsonPath };
 };
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/lint",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "A fast, format-agnostic JSON/YAML style-guide linter with JSON Schema and custom rules.",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -69,12 +69,12 @@
     }
   },
   "dependencies": {
-    "@amritk/runtime-validators": "^0.15.0",
-    "@amritk/yaml": "^0.7.2",
+    "@amritk/runtime-validators": "^0.15.1",
+    "@amritk/yaml": "^0.8.0",
     "jsonc-parser": "^3.3.1"
   },
   "devDependencies": {
-    "@amritk/resolve-refs": "^0.7.1",
+    "@amritk/resolve-refs": "^0.9.0",
     "@stoplight/spectral-core": "^1.23.1",
     "@stoplight/spectral-parsers": "^1.0.5",
     "@stoplight/spectral-rulesets": "^1.22.7"