@amritk/lint 0.4.3 → 0.4.5

package/AI.md

@@ -36,13 +36,27 @@ const findings = await lintDocument('version: 1\n', { ruleset, source: 'service.
    `rulesetBasePath` (or the ruleset file's own directory).
 5. **OpenAPI support is a separate subpath**, `@amritk/lint/rules/openapi`
    (`createOpenApiRuleset`, `oas`, `oasFixers`, …) — not the package root.
+6. **A ruleset is privileged; a document is not.** Linted documents cannot
+   execute anything, and `[?(...)]` filters in a `given` are parsed and
+   interpreted rather than evaluated as JavaScript. But `extends` follows any
+   path (absolute or `../`-escaping) and `require`s `.js` targets and custom
+   functions — that is code execution by design. Load rulesets from sources you
+   would trust to run a script, or pass `restrictTo: '<root>'` to confine
+   `extends`/`functions` resolution to one directory tree. See the README's
+   "Trust boundary" section.
+7. **`createRuleset` is memoized** per `(definition object, basePath,
+   restrictTo)`. Mutating a definition you already passed in will not rebuild the
+   ruleset — pass a fresh object instead.
 
 ## Exports
 
 - `lintDocument(input, options?)` → findings only.
 - `lintDocumentWithResult(input, options?)` → `{ diagnostics, output?, pluginData }`.
-- `fixDocument(input, options?)` → `{ output, fixed, applied, remaining }` (needs `fixers`).
-- `createRuleset(def?, basePath?)`, `resolveNamedRuleset(name, basePath?)`,
+- `fixDocument(input, options?)` → `{ output, fixed, applied, remaining, converged, passes }`
+  (needs `fixers`; `converged: false` means the 10-pass cap was hit with the
+  document still changing).
+- `createRuleset(def?, basePath?, { restrictTo }?)`,
+  `resolveNamedRuleset(name, basePath?, { restrictTo }?)`,
   `builtinFunctions` (`alphabetical`, `casing`, `truthy`, `pattern`, `schema`, …).
 
 ## Subpaths

package/README.md

@@ -105,6 +105,26 @@ await lintDocument(source, { ruleset: definition, rulesetBasePath: '/path/to/con
 
 A custom function has the signature `(value, options, context) => { message: string, path?: JsonPath }[]`.
 
+### Trust boundary — who may write a ruleset
+
+A **document** being linted is untrusted input: it is parsed, walked, and matched, and nothing in it can execute code. A **ruleset** is not input — it is configuration, and it is as privileged as the process running the linter:
+
+- `extends` accepts **any** path. `rulesetBasePath` is where resolution *starts*, not a fence: `../../../elsewhere/rules.yaml` and `/etc/rules.yaml` both resolve and load.
+- `extends` of a `.js` / `.cjs` / `.mjs` file, and every custom function named in `functions`, is `require`d — **that is code execution, by design**. This is how custom functions work.
+- YAML/JSON rulesets are *data*: their `given` filter expressions (`[?(...)]`) are parsed and interpreted, never evaluated as JavaScript, so a data-only ruleset cannot run code. A ruleset that names a `.js` file still can.
+
+So: load rulesets from sources you would trust to run a script. If you accept a ruleset from somewhere less trusted (a multi-tenant service, a PR from a fork), pass **`restrictTo`** — an optional root that every `extends` target and custom function must resolve under:
+
+```ts
+await lintDocument(source, {
+  ruleset: definition,
+  rulesetBasePath: '/srv/rulesets/tenant-42',
+  restrictTo: '/srv/rulesets/tenant-42', // refuse anything resolving outside this tree
+})
+```
+
+`restrictTo` is off by default and narrows *which* files a ruleset can name. It is not a sandbox: a `.js` file inside the permitted root still runs with full privileges.
+
 ### Auto-fix
 
 `fixDocument` runs the linter and applies a `FixerRegistry` — fixers keyed by rule `code` that map a finding to a formatting-preserving text edit — to a fixpoint, then re-lints:
@@ -127,6 +147,8 @@ const { output, applied, remaining } = await fixDocument('host: api.example.com/
 
 The engine ships no built-in fixers (rule codes are yours to define), so the default registry is empty and `fixDocument` is a no-op until you supply one.
 
+Fixing runs to a fixpoint, capped at 10 passes. The result reports how that ended: **`converged`** is `false` when the cap was hit while the document was still changing (usually two fixers undoing each other), and **`passes`** counts the passes that changed something. `applied` is de-duplicated by rule code and path, so a report can safely say "fixed N problems".
+
 ### Rendering findings
 
 `lintDocument` returns structured `IDiagnostic[]` — each with a `code`, `message`, `path`, `severity`, `source`, and a zero-based `range`. **Rendering is the caller's job**: print them, serialize them to JSON, or map them to whatever your editor or CI consumes. The linter deliberately ships no output "formatter" layer (that is not the same thing as `prettier`/`biome format`, which reformat source).
@@ -166,6 +188,21 @@ A ruleset is a plain object (authored as YAML, JSON, or a JS module):
 
 Built-in functions: `alphabetical`, `casing`, `defined`, `enumeration`, `falsy`, `length`, `or`, `pattern`, `schema`, `truthy`, `undefined`, `unreferencedReusableObject`, `xor`, `typedEnum`.
 
+### `given` — the JSONPath subset
+
+`$`, child and `['child']` access, `..` recursive descent, `[*]` / `.*` wildcards, `[a,b]` unions, `[n]` indices (negative counts from the end), `[start:end:step]` slices, `[(@.length-1)]`, `^` (parent) and `~` (property name), and `[?(...)]` filters.
+
+Filters are **parsed and interpreted, not evaluated as JavaScript** — a ruleset is data and cannot execute code. The supported grammar:
+
+| | |
+| --- | --- |
+| Context | `@`, `@.name`, `@['name']`, `@[0]`, `@property`, `@parentProperty`, `@parent`, `@path`, `@root`, `$` |
+| Operators | `===` `!==` `==` `!=` `<` `<=` `>` `>=` `&&` `\|\|` `!` `-` (negation), parentheses |
+| Literals | strings, numbers, `true`, `false`, `null`, `undefined`, `void 0`, `/regex/flags` |
+| Members & calls | `.length`, `.indexOf(…)`, `.lastIndexOf(…)`, `.includes(…)`, `.startsWith(…)`, `.endsWith(…)`, `.match(/re/)`, `/re/.test(…)`, `.toLowerCase()`, `.toUpperCase()`, `.trim()` |
+
+Anything outside that grammar is a ruleset error (`createRuleset` throws and names the rule) rather than a filter that quietly matches nothing. Member reads see **own properties only**, so `@.constructor` and `@['__proto__']` are plain `undefined`.
+
 ---
 
 ## API
@@ -174,9 +211,9 @@ Built-in functions: `alphabetical`, `casing`, `defined`, `enumeration`, `falsy`,
 | --- | --- |
 | `lintDocument(input, options?)` | Parse `input` and lint it against `options.ruleset`; returns `IDiagnostic[]`. |
 | `lintDocumentWithResult(input, options?)` | Like `lintDocument`, but returns `{ diagnostics, output?, pluginData }` (including any plugin's rewritten `output`). |
-| `fixDocument(input, options?)` | Lint and apply `options.fixers` to a fixpoint; returns `{ output, fixed, applied, remaining }`. |
-| `createRuleset(definition?, basePath?)` | Normalize a ruleset definition into a runnable `Ruleset`, layering the built-in functions and resolving `extends`. |
-| `resolveNamedRuleset(name, basePath?)` | Resolve an `extends` reference (file path or npm package) to its definition. |
+| `fixDocument(input, options?)` | Lint and apply `options.fixers` to a fixpoint; returns `{ output, fixed, applied, remaining, converged, passes }`. |
+| `createRuleset(definition?, basePath?, options?)` | Normalize a ruleset definition into a runnable `Ruleset`, layering the built-in functions and resolving `extends`. Memoized per `(definition object, basePath, restrictTo)` — treat a definition you have passed in as frozen. |
+| `resolveNamedRuleset(name, basePath?, options?)` | Resolve an `extends` reference (file path or npm package) to its definition. |
 | `builtinFunctions` | The registry of built-in rule functions. |
 
 The engine internals (`createDocument`, `lint`, `query`, `validateRuleset`, `parseWithPointers`, `createFixPlugin`, `DiagnosticSeverity`, and the rule/diagnostic types) are re-exported from the package root for advanced use.
@@ -220,15 +257,15 @@ The `bench/` suite pits `@amritk/lint` head-to-head against **[Spectral](https:/
 
 | document | size | mjst | Spectral | speedup | findings (mjst / Spectral) |
 | --- | ---: | ---: | ---: | ---: | ---: |
-| petstore (Swagger) | 17 KB | ~7 ms | ~100 ms | **~14×** | 2 / 2 |
-| digitalocean | 105 KB | ~31 ms | ~355 ms | **~12×** | 2411 / 4319 |
+| petstore (Swagger) | 17 KB | ~8 ms | ~93 ms | **~11×** | 2 / 2 |
+| digitalocean | 105 KB | ~31 ms | ~351 ms | **~11×** | 2411 / 4319 |
 | openai | 2.8 MB | ~1.4 s | errored¹ | — | 1278 / — |
 
 ¹ Spectral's JSONPath engine (`nimma`) throws on the 2.8 MB OpenAI spec under Bun, so that row is mjst-only; mjst lints it end to end.
 
 Each `lint` figure is the mean wall time of one whole pass — **every rule, not a subset** — dominated by real work: JSONPath matching, the rule functions, and the dereference pass. A fresh document is parsed on every iteration on both sides, matching how the tools are actually called. The finding counts differ because the two rulesets are not byte-identical (different rule implementations and `$ref` resolution), so this is a **throughput** comparison rather than a correctness parity check — but on petstore both land on the same two findings.
 
-**Assembling the ruleset** is timed separately, because a process pays it once and then lints many documents: `createOpenApiRuleset` (compiling every rule's JSONPath and wiring up functions and format detectors) measures **~0.09 ms**, versus **~0.35 ms** for `new Spectral()` + `setRuleset(oas)`. The benchmark warms up before timing and reports the mean over a fixed time budget; micro-benchmark figures vary by machine and runtime.
+**Assembling the ruleset** is timed separately, because a process pays it once and then lints many documents: `createOpenApiRuleset` (compiling every rule's JSONPath and wiring up functions and format detectors) measures **~0.07 ms**, versus **~0.27 ms** for `new Spectral()` + `setRuleset(oas)`. The benchmark warms up before timing and reports the mean over a fixed time budget; micro-benchmark figures vary by machine and runtime.
 
 ---
 

package/dist/core/bounded-cache.d.ts

@@ -0,0 +1,18 @@
+/** A memoization map with a hard entry cap. */
+export type BoundedCache<K, V> = {
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+    /** Current entry count — exposed for tests and diagnostics. */
+    readonly size: number;
+};
+/**
+ * Builds a cache that never grows past `limit` entries. The keys we memoize on
+ * (JSONPath expressions, filter bodies, regex sources) all come from rulesets,
+ * and a long-lived service that accepts a ruleset per request would otherwise
+ * grow these maps forever — a slow leak that only shows up in production.
+ *
+ * Eviction is plain insertion-order (a `Map` iterates oldest first), not LRU: the
+ * hot entries in a lint run are the handful of expressions a ruleset actually
+ * uses, so anything fancier would cost more than it saves.
+ */
+export declare const createBoundedCache: <K, V>(limit: number) => BoundedCache<K, V>;

package/dist/core/bounded-cache.js

@@ -0,0 +1,20 @@
+const createBoundedCache = (limit) => {
+  const entries = /* @__PURE__ */ new Map();
+  return {
+    get: (key) => entries.get(key),
+    set: (key, value) => {
+      if (entries.size >= limit && !entries.has(key)) {
+        const oldest = entries.keys().next();
+        if (!oldest.done)
+          entries.delete(oldest.value);
+      }
+      entries.set(key, value);
+    },
+    get size() {
+      return entries.size;
+    }
+  };
+};
+export {
+  createBoundedCache
+};

package/dist/core/filter-expression.d.ts

@@ -0,0 +1,60 @@
+/** The `@…` tokens a filter can read from its evaluation context. */
+export type ContextRef = 'value' | 'property' | 'parent' | 'parentProperty' | 'path' | 'root';
+/** One node of a parsed filter expression. */
+export type FilterNode = {
+    kind: 'literal';
+    value: unknown;
+} | {
+    kind: 'regex';
+    value: RegExp;
+} | {
+    kind: 'context';
+    ref: ContextRef;
+}
+/** `@.name` — a static member read. */
+ | {
+    kind: 'member';
+    object: FilterNode;
+    name: string;
+}
+/** `@['name']` / `@[0]` — a member read through an expression. */
+ | {
+    kind: 'computed';
+    object: FilterNode;
+    index: FilterNode;
+}
+/** `@.indexOf('x')` — a call to one of the allowed pure methods. */
+ | {
+    kind: 'call';
+    object: FilterNode;
+    name: string;
+    args: FilterNode[];
+} | {
+    kind: 'unary';
+    operator: '!' | '-' | 'void';
+    operand: FilterNode;
+} | {
+    kind: 'comparison';
+    operator: ComparisonOperator;
+    left: FilterNode;
+    right: FilterNode;
+} | {
+    kind: 'logical';
+    operator: '&&' | '||';
+    left: FilterNode;
+    right: FilterNode;
+};
+export type ComparisonOperator = '===' | '!==' | '==' | '!=' | '<' | '<=' | '>' | '>=';
+/** A successfully parsed filter, plus whether it reads `@path` (materializing that is not free). */
+export type ParsedFilter = {
+    node: FilterNode;
+    usesPath: boolean;
+};
+/**
+ * Parses a filter body into a {@link ParsedFilter}, or returns the reason it
+ * could not. Precedence follows JavaScript: `||` < `&&` < equality < relational
+ * < unary < member/call.
+ */
+export declare const parseFilterExpression: (source: string) => ParsedFilter | {
+    error: string;
+};

package/dist/core/filter-expression.js

@@ -0,0 +1,320 @@
+const CONTEXT_TOKENS = {
+  "@": "value",
+  "@property": "property",
+  "@parentProperty": "parentProperty",
+  "@parent": "parent",
+  "@path": "path",
+  "@root": "root"
+};
+const KEYWORDS = {
+  true: true,
+  false: false,
+  null: null,
+  undefined: void 0
+};
+const PUNCTUATORS = ["===", "!==", "==", "!=", "<=", ">=", "&&", "||", "!", "<", ">", "(", ")", "[", "]", ".", ",", "-"];
+const isNameStart = (ch) => /[A-Za-z_$]/.test(ch);
+const isNameChar = (ch) => /[A-Za-z0-9_$]/.test(ch);
+const isDigit = (ch) => ch >= "0" && ch <= "9";
+const fail = (message, offset) => {
+  const error = new Error(message);
+  error.offset = offset;
+  throw error;
+};
+const readString = (source, start) => {
+  const quote = source[start];
+  let out = "";
+  let i = start + 1;
+  while (i < source.length) {
+    const ch = source[i];
+    if (ch === "\\") {
+      const next = source[i + 1];
+      if (next === void 0)
+        fail("Unterminated string literal", start);
+      const escapes = { n: "\n", r: "\r", t: "	", b: "\b", f: "\f", v: "\v", "0": "\0" };
+      out += escapes[next] ?? next;
+      i += 2;
+      continue;
+    }
+    if (ch === quote)
+      return { value: out, end: i + 1 };
+    out += ch;
+    i++;
+  }
+  return fail("Unterminated string literal", start);
+};
+const readRegExp = (source, start) => {
+  let i = start + 1;
+  let inClass = false;
+  let pattern = "";
+  while (i < source.length) {
+    const ch = source[i];
+    if (ch === "\\") {
+      pattern += ch + (source[i + 1] ?? "");
+      i += 2;
+      continue;
+    }
+    if (ch === "[")
+      inClass = true;
+    else if (ch === "]")
+      inClass = false;
+    else if (ch === "/" && !inClass)
+      break;
+    pattern += ch;
+    i++;
+  }
+  if (source[i] !== "/")
+    return fail("Unterminated regular expression literal", start);
+  i++;
+  let flags = "";
+  while (i < source.length && isNameChar(source[i])) {
+    flags += source[i];
+    i++;
+  }
+  try {
+    return { value: new RegExp(pattern, flags), end: i };
+  } catch (error) {
+    return fail(`Invalid regular expression: ${error.message}`, start);
+  }
+};
+const tokenize = (source) => {
+  const tokens = [];
+  let i = 0;
+  while (i < source.length) {
+    const ch = source[i];
+    if (/\s/.test(ch)) {
+      i++;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      const { value, end } = readString(source, i);
+      tokens.push({ kind: "value", value, start: i });
+      i = end;
+      continue;
+    }
+    if (ch === "/") {
+      const { value, end } = readRegExp(source, i);
+      tokens.push({ kind: "regex", value, start: i });
+      i = end;
+      continue;
+    }
+    if (ch === "@") {
+      let end = i + 1;
+      while (end < source.length && isNameChar(source[end]))
+        end++;
+      const text = source.slice(i, end);
+      const ref = CONTEXT_TOKENS[text];
+      if (ref === void 0)
+        fail(`Unsupported context token "${text}"`, i);
+      tokens.push({ kind: "context", ref, start: i });
+      i = end;
+      continue;
+    }
+    if (ch === "$") {
+      if (!isNameChar(source[i + 1] ?? "")) {
+        tokens.push({ kind: "context", ref: "root", start: i });
+        i++;
+        continue;
+      }
+    }
+    if (isDigit(ch)) {
+      let end = i;
+      while (end < source.length && /[0-9.eE]/.test(source[end])) {
+        if ((source[end] === "e" || source[end] === "E") && (source[end + 1] === "-" || source[end + 1] === "+"))
+          end++;
+        end++;
+      }
+      const text = source.slice(i, end);
+      const value = Number(text);
+      if (Number.isNaN(value))
+        fail(`Invalid number "${text}"`, i);
+      tokens.push({ kind: "value", value, start: i });
+      i = end;
+      continue;
+    }
+    if (isNameStart(ch)) {
+      let end = i;
+      while (end < source.length && isNameChar(source[end]))
+        end++;
+      tokens.push({ kind: "name", text: source.slice(i, end), start: i });
+      i = end;
+      continue;
+    }
+    const punct = PUNCTUATORS.find((candidate) => source.startsWith(candidate, i));
+    if (punct === void 0)
+      fail(`Unexpected character "${ch}"`, i);
+    tokens.push({ kind: "punct", text: punct, start: i });
+    i += punct.length;
+  }
+  return tokens;
+};
+const ALLOWED_METHODS = /* @__PURE__ */ new Set([
+  "indexOf",
+  "lastIndexOf",
+  "includes",
+  "startsWith",
+  "endsWith",
+  "match",
+  "test",
+  "toLowerCase",
+  "toUpperCase",
+  "trim"
+]);
+const parseFilterExpression = (source) => {
+  let tokens;
+  try {
+    tokens = tokenize(source);
+  } catch (error) {
+    const syntax = error;
+    return { error: `${syntax.message} at offset ${syntax.offset} in filter "${source}"` };
+  }
+  let position = 0;
+  let usesPath = false;
+  const peek = () => tokens[position];
+  const offsetOf = (token) => token?.start ?? source.length;
+  const eatPunct = (text) => {
+    const token = peek();
+    if (token?.kind === "punct" && token.text === text) {
+      position++;
+      return true;
+    }
+    return false;
+  };
+  const expectPunct = (text) => {
+    if (!eatPunct(text))
+      fail(`Expected "${text}"`, offsetOf(peek()));
+  };
+  const parseArguments = () => {
+    const args = [];
+    if (eatPunct(")"))
+      return args;
+    for (; ; ) {
+      args.push(parseOr());
+      if (eatPunct(")"))
+        return args;
+      expectPunct(",");
+    }
+  };
+  const parsePostfix = (object) => {
+    let node = object;
+    for (; ; ) {
+      if (eatPunct(".")) {
+        const token = peek();
+        if (token?.kind !== "name")
+          return fail('Expected a property name after "."', offsetOf(token));
+        position++;
+        if (eatPunct("(")) {
+          if (!ALLOWED_METHODS.has(token.text))
+            fail(`Unsupported method "${token.text}()"`, token.start);
+          node = { kind: "call", object: node, name: token.text, args: parseArguments() };
+          continue;
+        }
+        node = { kind: "member", object: node, name: token.text };
+        continue;
+      }
+      if (eatPunct("[")) {
+        const index = parseOr();
+        expectPunct("]");
+        node = { kind: "computed", object: node, index };
+        continue;
+      }
+      return node;
+    }
+  };
+  const parsePrimary = () => {
+    const token = peek();
+    if (token === void 0)
+      return fail("Unexpected end of filter expression", source.length);
+    if (token.kind === "value") {
+      position++;
+      return parsePostfix({ kind: "literal", value: token.value });
+    }
+    if (token.kind === "regex") {
+      position++;
+      return parsePostfix({ kind: "regex", value: token.value });
+    }
+    if (token.kind === "context") {
+      position++;
+      if (token.ref === "path")
+        usesPath = true;
+      return parsePostfix({ kind: "context", ref: token.ref });
+    }
+    if (token.kind === "name") {
+      if (token.text in KEYWORDS) {
+        position++;
+        return parsePostfix({ kind: "literal", value: KEYWORDS[token.text] });
+      }
+      return fail(`Unsupported identifier "${token.text}"`, token.start);
+    }
+    if (token.text === "(") {
+      position++;
+      const inner = parseOr();
+      expectPunct(")");
+      return parsePostfix(inner);
+    }
+    return fail(`Unexpected token "${token.text}"`, token.start);
+  };
+  const parseUnary = () => {
+    const token = peek();
+    if (token?.kind === "punct" && (token.text === "!" || token.text === "-")) {
+      position++;
+      return { kind: "unary", operator: token.text, operand: parseUnary() };
+    }
+    if (token?.kind === "name" && token.text === "void") {
+      position++;
+      return { kind: "unary", operator: "void", operand: parseUnary() };
+    }
+    return parsePrimary();
+  };
+  const parseRelational = () => {
+    let left = parseUnary();
+    for (; ; ) {
+      const token = peek();
+      if (token?.kind !== "punct")
+        return left;
+      if (token.text !== "<" && token.text !== "<=" && token.text !== ">" && token.text !== ">=")
+        return left;
+      position++;
+      left = { kind: "comparison", operator: token.text, left, right: parseUnary() };
+    }
+  };
+  const parseEquality = () => {
+    let left = parseRelational();
+    for (; ; ) {
+      const token = peek();
+      if (token?.kind !== "punct")
+        return left;
+      if (token.text !== "===" && token.text !== "!==" && token.text !== "==" && token.text !== "!=")
+        return left;
+      position++;
+      left = { kind: "comparison", operator: token.text, left, right: parseRelational() };
+    }
+  };
+  const parseAnd = () => {
+    let left = parseEquality();
+    while (eatPunct("&&"))
+      left = { kind: "logical", operator: "&&", left, right: parseEquality() };
+    return left;
+  };
+  const parseOr = () => {
+    let left = parseAnd();
+    while (eatPunct("||"))
+      left = { kind: "logical", operator: "||", left, right: parseAnd() };
+    return left;
+  };
+  try {
+    if (tokens.length === 0)
+      return { error: `Empty filter expression "${source}"` };
+    const node = parseOr();
+    const trailing = peek();
+    if (trailing !== void 0)
+      fail(`Unexpected token "${"text" in trailing ? trailing.text : ""}"`, trailing.start);
+    return { node, usesPath };
+  } catch (error) {
+    const syntax = error;
+    return { error: `${syntax.message} at offset ${syntax.offset} in filter "${source}"` };
+  }
+};
+export {
+  parseFilterExpression
+};

package/dist/core/filter.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Evaluates one `[?(...)]` filter against a candidate node. Arguments are passed
+ * positionally rather than in a context object because this runs once per node
+ * of the document — the allocation would show up on large specs.
+ *
+ * `path` is the jsonpath-plus string form (`$['a'][0]`) that `@path` exposes, and
+ * is only materialized for filters that actually reference it.
+ */
+export type FilterFn = (value: unknown, property: string | number | undefined, parent: unknown, root: unknown, path: string, parentProperty: string | number | undefined) => boolean;
+/** A filter that either compiled, or the reason it did not. */
+export type CompiledFilter = {
+    readonly test: FilterFn;
+    readonly usesPath: boolean;
+} | {
+    readonly error: string;
+};
+/**
+ * Compiles a `[?(...)]` filter body into a predicate, or reports why it cannot.
+ *
+ * There is no `eval` and no `new Function` anywhere in this path: the body is
+ * parsed into an AST ({@link parseFilterExpression}) and interpreted. A ruleset
+ * — which is data, and often YAML written by someone other than the person
+ * running the linter — therefore cannot execute code in the host process.
+ */
+export declare const compileFilter: (source: string) => CompiledFilter;