@amritk/lint 0.4.8 → 0.5.0

package/dist/rules/asyncapi/schemas/index.d.ts

@@ -0,0 +1,20 @@
+/** The AsyncAPI versions with a bundled structural meta-schema. */
+export type AsyncApiVersion = '2.0' | '2.1' | '2.2' | '2.3' | '2.4' | '2.5' | '2.6' | '3.0';
+/** The bundled versions, oldest first. `asyncapi-latest-version` reports the last one. */
+export declare const ASYNCAPI_VERSIONS: AsyncApiVersion[];
+/** The newest AsyncAPI release this package ships a meta-schema for, as a full `x.y.z` version. */
+export declare const LATEST_ASYNCAPI_VERSION = "3.0.0";
+/**
+ * Parses (and memoizes) the official structural meta-schema for one AsyncAPI
+ * version. The returned object is stable across calls, so downstream validator
+ * caches (keyed by schema identity) stay warm.
+ */
+export declare const loadAsyncApiSchema: (version: AsyncApiVersion) => object;
+/**
+ * Maps a document's `asyncapi` string to the bundled meta-schema version, or
+ * `undefined` when no bundled schema covers it. Patch releases share their
+ * minor's schema (`2.6.4` → `2.6`), which is how the spec publishes them; an
+ * unbundled minor such as a future `2.7.0` returns `undefined` so callers report
+ * nothing rather than validating against the wrong version.
+ */
+export declare const asyncApiSchemaVersion: (declared: unknown) => AsyncApiVersion | undefined;

package/dist/rules/asyncapi/schemas/index.js

@@ -0,0 +1,45 @@
+import { aas20Json } from "./aas20.js";
+import { aas21Json } from "./aas21.js";
+import { aas22Json } from "./aas22.js";
+import { aas23Json } from "./aas23.js";
+import { aas24Json } from "./aas24.js";
+import { aas25Json } from "./aas25.js";
+import { aas26Json } from "./aas26.js";
+import { aas30Json } from "./aas30.js";
+const SCHEMA_TEXT = {
+  "2.0": aas20Json,
+  "2.1": aas21Json,
+  "2.2": aas22Json,
+  "2.3": aas23Json,
+  "2.4": aas24Json,
+  "2.5": aas25Json,
+  "2.6": aas26Json,
+  "3.0": aas30Json
+};
+const ASYNCAPI_VERSIONS = Object.keys(SCHEMA_TEXT);
+const LATEST_ASYNCAPI_VERSION = "3.0.0";
+const cache = /* @__PURE__ */ new Map();
+const loadAsyncApiSchema = (version) => {
+  let schema = cache.get(version);
+  if (!schema) {
+    const text = Object.hasOwn(SCHEMA_TEXT, version) ? SCHEMA_TEXT[version] : void 0;
+    if (text === void 0) {
+      throw new Error(`Unknown AsyncAPI version "${version}". Known versions are: ${Object.keys(SCHEMA_TEXT).join(", ")}`);
+    }
+    schema = JSON.parse(text);
+    cache.set(version, schema);
+  }
+  return schema;
+};
+const asyncApiSchemaVersion = (declared) => {
+  if (typeof declared !== "string")
+    return void 0;
+  const minor = /^(\d+\.\d+)(?:\.|$)/.exec(declared)?.[1];
+  return minor !== void 0 && Object.hasOwn(SCHEMA_TEXT, minor) ? minor : void 0;
+};
+export {
+  ASYNCAPI_VERSIONS,
+  LATEST_ASYNCAPI_VERSION,
+  asyncApiSchemaVersion,
+  loadAsyncApiSchema
+};

package/dist/rules/openapi/fixers.d.ts

@@ -1,7 +1,11 @@
 import type { FixerRegistry } from '../../fix/index.js';
 /**
- * Auto-fixers for the mechanically-repairable OpenAPI rules, keyed by rule
- * code. Pass these to `@amritk/lint`'s `fixDocument` (as its `fixers`), or wrap
+ * Auto-fixers for the mechanically-repairable OpenAPI rules, keyed by rule code.
+ *
+ * Pass these to `@amritk/lint`'s `fixDocument` as its `fixers`, together with a
+ * ruleset built by `createOpenApiRuleset` — the OpenAPI rules need that
+ * preset's functions and format detectors, so handing `fixDocument` the `oas`
+ * definition as plain data produces no findings and therefore no fixes. Or wrap
  * them with `createFixPlugin` for a lower-level plugin.
  */
 export declare const oasFixers: FixerRegistry;

package/dist/rules/openapi/fixers.js

@@ -4,6 +4,8 @@ const getAtPath = (data, path) => {
   for (const segment of path) {
     if (current == null || typeof current !== "object")
       return void 0;
+    if (!Object.hasOwn(current, segment))
+      return void 0;
     current = current[segment];
   }
   return current;

package/dist/rules/openapi/functions/oas-discriminator.js

@@ -6,7 +6,7 @@ const oasDiscriminator = (schema, _options, context) => {
   const required = Array.isArray(schema["required"]) ? schema["required"] : [];
   const properties = isObject(schema["properties"]) ? schema["properties"] : {};
   const results = [];
-  if (!(property in properties)) {
+  if (!Object.hasOwn(properties, property)) {
     results.push({
       message: `Discriminator "${property}" must be defined in properties`,
       path: [...context.path, "discriminator"]

package/dist/rules/openapi/functions/oas-mutually-exclusive.js

@@ -2,7 +2,7 @@ import { isObject } from "./helpers.js";
 const oasMutuallyExclusive = (input, options, context) => {
   if (!isObject(input))
     return [];
-  const present = (options?.properties ?? []).filter((property) => input[property] !== void 0);
+  const present = (options?.properties ?? []).filter((property) => Object.hasOwn(input, property) && input[property] !== void 0);
   if (present.length <= 1)
     return [];
   const [anchor, ...conflicts] = present;

package/dist/rules/openapi/functions/oas-op-security-defined.js

@@ -2,7 +2,7 @@ import { isObject, OPERATION_METHODS } from "./helpers.js";
 const getIn = (root, path) => {
   let current = root;
   for (const key of path) {
-    if (!isObject(current))
+    if (!isObject(current) || !Object.hasOwn(current, key))
       return void 0;
     current = current[key];
   }

package/dist/rules/openapi/functions/oas-server-variables.d.ts

@@ -1,8 +1,8 @@
-import type { RulesetFunction } from '../../../core/types.js';
+import { type IServerVariablesOptions } from '../../shared/server-variables.js';
 /**
- * Validates a Server Object's `variables`, mirroring Spectral's `serverVariables`:
- * every `{template}` in the URL must have a matching variable and vice versa, and
- * each defined variable must have a `default`, a non-empty `enum` when present,
- * and a `default` that is listed in that `enum`.
+ * Validates a Server Object's `variables`. The OpenAPI and AsyncAPI Server
+ * Objects are the same shape here, so the implementation is shared — see
+ * {@link serverVariables}.
  */
-export declare const oasServerVariables: RulesetFunction;
+export declare const oasServerVariables: import("../../../core/types.js").RulesetFunction<unknown, IServerVariablesOptions | undefined>;
+export type { IServerVariablesOptions };

package/dist/rules/openapi/functions/oas-server-variables.js

@@ -1,48 +1,5 @@
-import { isObject } from "./helpers.js";
-const oasServerVariables = (server, _options, context) => {
-  if (!isObject(server) || typeof server["url"] !== "string")
-    return [];
-  const templates = [...server["url"].matchAll(/\{([^}]+)\}/g)].map((m) => m[1]);
-  const variables = isObject(server["variables"]) ? server["variables"] : {};
-  const results = [];
-  for (const template of templates) {
-    if (!(template in variables)) {
-      results.push({ message: `Server variable "${template}" is not defined`, path: [...context.path, "variables"] });
-    }
-  }
-  for (const [name, variable] of Object.entries(variables)) {
-    if (!templates.includes(name)) {
-      results.push({
-        message: `Server variable "${name}" is not used in the URL`,
-        path: [...context.path, "variables", name]
-      });
-    }
-    if (!isObject(variable))
-      continue;
-    const hasDefault = variable["default"] !== void 0;
-    if (!hasDefault) {
-      results.push({
-        message: `Server variable "${name}" has a missing default`,
-        path: [...context.path, "variables", name]
-      });
-    }
-    if ("enum" in variable) {
-      const enumValues = Array.isArray(variable["enum"]) ? variable["enum"] : [];
-      if (enumValues.length === 0) {
-        results.push({
-          message: `Server variable "${name}" has an empty enum`,
-          path: [...context.path, "variables", name, "enum"]
-        });
-      } else if (hasDefault && !enumValues.includes(variable["default"])) {
-        results.push({
-          message: `Server variable "${name}" has a default not listed in the enum`,
-          path: [...context.path, "variables", name, "default"]
-        });
-      }
-    }
-  }
-  return results;
-};
+import { serverVariables } from "../../shared/server-variables.js";
+const oasServerVariables = serverVariables;
 export {
   oasServerVariables
 };

package/dist/rules/openapi/functions/oas-tags-unique.d.ts

@@ -1,3 +1,2 @@
-import type { RulesetFunction } from '../../../core/types.js';
-/** Flags duplicate global tag names. */
-export declare const oasTagsUnique: RulesetFunction;
+/** Flags duplicate global tag names. Shared with AsyncAPI — see {@link tagsUnique}. */
+export declare const oasTagsUnique: import("../../../core/types.js").RulesetFunction;

package/dist/rules/openapi/functions/oas-tags-unique.js

@@ -1,19 +1,5 @@
-import { isObject } from "./helpers.js";
-const oasTagsUnique = (tags, _options, context) => {
-  if (!Array.isArray(tags))
-    return [];
-  const seen = /* @__PURE__ */ new Set();
-  const results = [];
-  tags.forEach((tag, index) => {
-    if (!isObject(tag) || typeof tag["name"] !== "string")
-      return;
-    if (seen.has(tag["name"])) {
-      results.push({ message: `Duplicate tag name "${tag["name"]}"`, path: [...context.path, index, "name"] });
-    }
-    seen.add(tag["name"]);
-  });
-  return results;
-};
+import { tagsUnique } from "../../shared/tags-unique.js";
+const oasTagsUnique = tagsUnique;
 export {
   oasTagsUnique
 };

package/dist/rules/openapi/functions/oas-unused-component.js

@@ -1,3 +1,4 @@
+import { collectReferencedPointers } from "../../../functions/ref-index.js";
 import { isObject } from "./helpers.js";
 const REUSABLE_COMPONENT_TYPES = [
   "schemas",
@@ -10,40 +11,17 @@ const REUSABLE_COMPONENT_TYPES = [
   "callbacks",
   "pathItems"
 ];
-const collectRefs = (node, into) => {
-  if (Array.isArray(node)) {
-    for (const item of node)
-      collectRefs(item, into);
-    return;
-  }
-  if (isObject(node)) {
-    for (const [key, value] of Object.entries(node)) {
-      if (key === "$ref" && typeof value === "string")
-        into.add(value);
-      else
-        collectRefs(value, into);
-    }
-  }
-};
 const oasUnusedComponent = (components, _options, context) => {
   if (!isObject(components))
     return [];
-  const refs = /* @__PURE__ */ new Set();
-  collectRefs(context.document.data, refs);
-  const isReferenced = (base) => {
-    for (const ref of refs) {
-      if (ref === base || ref.startsWith(`${base}/`))
-        return true;
-    }
-    return false;
-  };
+  const referenced = collectReferencedPointers(context.document.data);
   const results = [];
   for (const type of REUSABLE_COMPONENT_TYPES) {
     const group = components[type];
     if (!isObject(group))
       continue;
     for (const key of Object.keys(group)) {
-      if (!isReferenced(`#/components/${type}/${key}`)) {
+      if (!referenced.has(`#/components/${type}/${key}`)) {
         results.push({ message: "Potentially unused component has been detected.", path: [...context.path, type, key] });
       }
     }

package/dist/rules/openapi/index.d.ts

@@ -1,5 +1,7 @@
 import { type ResolvedExtend, type Ruleset } from '../../core/index.js';
 import type { FunctionRegistry, RulesetDefinition } from '../../core/types.js';
+import { type IRulesetTrustOptions } from '../../ruleset-files.js';
+export type { IRulesetTrustOptions } from '../../ruleset-files.js';
 export { oasFixers } from './fixers.js';
 export { oas2, oas3, oas3_0, oas3_1, oas3_2, oasFormats } from './formats.js';
 export { oasFunctions } from './functions/index.js';
@@ -13,8 +15,13 @@ export declare const allFunctions: FunctionRegistry;
  * - `oas` / `loupe:oas` / `spectral:oas` → the built-in {@link oas} ruleset,
  * - local file paths (relative to `basePath`, or absolute): `.yaml` / `.yml` / `.json` / `.js`,
  * - npm package specifiers (resolved from `basePath`), including subpaths.
+ *
+ * As with the core `resolveNamedRuleset`, `basePath` is where resolution starts,
+ * not a boundary: an absolute or `../`-escaping path is followed and a `.js`
+ * target is `require`d. Pass `restrictTo` to confine resolution to one directory
+ * tree when the ruleset is not fully trusted.
  */
-export declare const resolveOpenApiRuleset: (name: string, basePath?: string) => ResolvedExtend;
+export declare const resolveOpenApiRuleset: (name: string, basePath?: string, options?: IRulesetTrustOptions) => ResolvedExtend;
 /**
  * Builds a runnable {@link Ruleset} for OpenAPI, layering the built-in and
  * OpenAPI functions (plus any custom ones the definition declares), the OpenAPI
@@ -23,4 +30,4 @@ export declare const resolveOpenApiRuleset: (name: string, basePath?: string) =>
  * (recommended rules only). Feed the result to `@amritk/lint`'s core
  * `lintWithResult` (with a `$ref` resolver for `resolved: true` rules).
  */
-export declare const createOpenApiRuleset: (definition?: RulesetDefinition, basePath?: string) => Ruleset;
+export declare const createOpenApiRuleset: (definition?: RulesetDefinition, basePath?: string, options?: IRulesetTrustOptions) => Ruleset;

package/dist/rules/openapi/index.js

@@ -1,9 +1,6 @@
-import { readFileSync } from "node:fs";
-import { createRequire } from "node:module";
-import { dirname, isAbsolute, resolve as resolvePath } from "node:path";
 import { createRuleset as createCoreRuleset } from "../../core/index.js";
 import { builtinFunctions } from "../../functions/index.js";
-import { parseWithPointers } from "../../parsers/index.js";
+import { collectCustomFunctions, resolveRulesetFile } from "../../ruleset-files.js";
 import { oasFormats } from "./formats.js";
 import { oasFunctions } from "./functions/index.js";
 import { oas } from "./oas.js";
@@ -13,82 +10,30 @@ import { oasFunctions as oasFunctions2 } from "./functions/index.js";
 import { oas as oas4 } from "./oas.js";
 import { loadOasSchema } from "./schemas/index.js";
 const allFunctions = { ...builtinFunctions, ...oasFunctions };
-const require2 = createRequire(import.meta.url);
 const OAS_RULESET_NAMES = /* @__PURE__ */ new Set(["oas", "loupe:oas", "spectral:oas"]);
-const loadRulesetFile = (file) => {
-  if (/\.(ya?ml|json)$/i.test(file)) {
-    return parseWithPointers(readFileSync(file, "utf8")).data;
-  }
-  const module = require2(file);
-  return module.default ?? module;
-};
-const resolveOpenApiRuleset = (name, basePath = process.cwd()) => {
+const resolveOpenApiRuleset = (name, basePath = process.cwd(), options = {}) => {
   if (OAS_RULESET_NAMES.has(name))
     return { definition: oas, basePath };
-  if (name.startsWith(".") || isAbsolute(name)) {
-    const file2 = resolvePath(basePath, name);
-    return { definition: loadRulesetFile(file2), basePath: dirname(file2) };
-  }
-  let file;
-  try {
-    file = require2.resolve(name, { paths: [basePath] });
-  } catch {
-    throw new Error(`Cannot resolve extended ruleset "${name}" from ${basePath}`);
-  }
-  return { definition: loadRulesetFile(file), basePath: dirname(file) };
-};
-const loadFunctionByName = (basePath, dir, name) => {
-  const baseFile = resolvePath(basePath, dir, name);
-  for (const candidate of [baseFile, `${baseFile}.js`, `${baseFile}.cjs`, `${baseFile}.mjs`]) {
-    try {
-      const resolvedFile = require2.resolve(candidate);
-      const module = require2(resolvedFile);
-      const fn = module.default ?? module;
-      if (typeof fn !== "function")
-        throw new Error(`"${name}" did not export a function`);
-      return fn;
-    } catch (error) {
-      if (error.code !== "MODULE_NOT_FOUND")
-        throw error;
-    }
-  }
-  throw new Error(`Cannot resolve custom function "${name}" from ${resolvePath(basePath, dir)}`);
+  return resolveRulesetFile(name, basePath, options);
 };
-const collectCustomFunctions = (definition, basePath, into, seen) => {
-  if (seen.has(definition))
-    return;
-  seen.add(definition);
-  if (definition.extends) {
-    const entries = Array.isArray(definition.extends) ? definition.extends : [definition.extends];
-    for (const entry of entries) {
-      const target = Array.isArray(entry) ? entry[0] : entry;
-      if (typeof target === "string") {
-        if (OAS_RULESET_NAMES.has(target))
-          continue;
-        const resolved = resolveOpenApiRuleset(target, basePath);
-        collectCustomFunctions(resolved.definition, resolved.basePath, into, seen);
-      } else {
-        collectCustomFunctions(target, basePath, into, seen);
-      }
-    }
-  }
-  if (Array.isArray(definition.functions)) {
-    const dir = definition.functionsDir ?? "functions";
-    for (const name of definition.functions)
-      into[name] = loadFunctionByName(basePath, dir, name);
-  }
-};
-const createOpenApiRuleset = (definition, basePath) => {
-  const resolved = definition ?? { extends: [oas] };
+const createOpenApiRuleset = (definition, basePath, options = {}) => {
+  const definitionOrDefault = definition ?? { extends: [oas] };
+  const trust = options.restrictTo !== void 0 ? { restrictTo: options.restrictTo } : {};
+  const resolve = (name, from) => resolveOpenApiRuleset(name, from, trust);
   let functions = allFunctions;
   const custom = {};
-  collectCustomFunctions(resolved, basePath ?? process.cwd(), custom, /* @__PURE__ */ new Set());
+  collectCustomFunctions(definitionOrDefault, basePath ?? process.cwd(), custom, /* @__PURE__ */ new Set(), {
+    ...trust,
+    // A built-in preset name has no directory of its own, so there is nothing to
+    // walk for custom functions.
+    resolveExtend: (name, from) => OAS_RULESET_NAMES.has(name) ? void 0 : resolve(name, from)
+  });
   if (Object.keys(custom).length > 0)
     functions = { ...allFunctions, ...custom };
-  return createCoreRuleset(resolved, {
+  return createCoreRuleset(definitionOrDefault, {
     functions,
     formats: oasFormats,
-    resolve: resolveOpenApiRuleset,
+    resolve,
     ...basePath !== void 0 ? { basePath } : {}
   });
 };

package/dist/rules/openapi/schemas/index.js

@@ -12,7 +12,11 @@ const cache = /* @__PURE__ */ new Map();
 const loadOasSchema = (version) => {
   let schema = cache.get(version);
   if (!schema) {
-    schema = JSON.parse(SCHEMA_TEXT[version]);
+    const text = Object.hasOwn(SCHEMA_TEXT, version) ? SCHEMA_TEXT[version] : void 0;
+    if (text === void 0) {
+      throw new Error(`Unknown OpenAPI version "${version}". Known versions are: ${Object.keys(SCHEMA_TEXT).join(", ")}`);
+    }
+    schema = JSON.parse(text);
     cache.set(version, schema);
   }
   return schema;

package/dist/rules/shared/helpers.d.ts

@@ -0,0 +1,2 @@
+/** True for a non-null, non-array object (a spec "object" value). */
+export declare const isObject: (value: unknown) => value is Record<string, unknown>;

package/dist/rules/shared/helpers.js

@@ -0,0 +1,4 @@
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+export {
+  isObject
+};

package/dist/rules/shared/server-variables.d.ts

@@ -0,0 +1,27 @@
+import type { RulesetFunction } from '../../core/types.js';
+/**
+ * Validates a Server Object's `variables`, mirroring Spectral's `serverVariables`:
+ * every `{template}` in the address must have a matching variable and vice
+ * versa, and each defined variable must have a `default`, a non-empty `enum`
+ * when present, and a `default` that is listed in that `enum`.
+ *
+ * All three specs model the Server Object the same way — a templated address
+ * plus a `variables` map — differing only in which field carries the address
+ * (see {@link TEMPLATED_FIELDS}), so they run this one implementation. See
+ * `oasServerVariables` and `aasServerVariables`.
+ */
+/** Options for {@link serverVariables}: which fields of the Server Object carry the address. */
+export type IServerVariablesOptions = {
+    /**
+     * The address fields to read templates from. Defaults to `['url']`, which is
+     * where OpenAPI and AsyncAPI 2.x put the whole address; AsyncAPI 3.0 split it
+     * into `host` and `pathname` and passes those instead.
+     *
+     * Not a union of all three: OpenAPI's `oas3-server-variables` runs under a
+     * recursive `$..links[*].server` given, so reading `host`/`pathname` there
+     * turned any object with those keys — an example payload, say — into an
+     * error-severity finding about undefined server variables.
+     */
+    addressFields?: readonly string[];
+};
+export declare const serverVariables: RulesetFunction<unknown, IServerVariablesOptions | undefined>;

package/dist/rules/shared/server-variables.js

@@ -0,0 +1,55 @@
+import { isObject } from "./helpers.js";
+const DEFAULT_ADDRESS_FIELDS = ["url"];
+const addressNoun = (fields) => fields.length === 1 && fields[0] === "url" ? "URL" : "address";
+const serverVariables = (server, options, context) => {
+  if (!isObject(server))
+    return [];
+  const fields = options?.addressFields ?? DEFAULT_ADDRESS_FIELDS;
+  const templated = fields.map((field) => Object.hasOwn(server, field) ? server[field] : void 0).filter((value) => typeof value === "string");
+  if (templated.length === 0)
+    return [];
+  const templates = templated.flatMap((value) => [...value.matchAll(/\{([^}]+)\}/g)].map((m) => m[1]));
+  const templateNames = new Set(templates);
+  const variables = isObject(server["variables"]) ? server["variables"] : {};
+  const results = [];
+  for (const template of templateNames) {
+    if (!Object.hasOwn(variables, template)) {
+      results.push({ message: `Server variable "${template}" is not defined`, path: [...context.path, "variables"] });
+    }
+  }
+  for (const [name, variable] of Object.entries(variables)) {
+    if (!templateNames.has(name)) {
+      results.push({
+        message: `Server variable "${name}" is not used in the ${addressNoun(fields)}`,
+        path: [...context.path, "variables", name]
+      });
+    }
+    if (!isObject(variable))
+      continue;
+    const hasDefault = variable["default"] !== void 0;
+    if (!hasDefault) {
+      results.push({
+        message: `Server variable "${name}" has a missing default`,
+        path: [...context.path, "variables", name]
+      });
+    }
+    if ("enum" in variable) {
+      const enumValues = Array.isArray(variable["enum"]) ? variable["enum"] : [];
+      if (enumValues.length === 0) {
+        results.push({
+          message: `Server variable "${name}" has an empty enum`,
+          path: [...context.path, "variables", name, "enum"]
+        });
+      } else if (hasDefault && !enumValues.includes(variable["default"])) {
+        results.push({
+          message: `Server variable "${name}" has a default not listed in the enum`,
+          path: [...context.path, "variables", name, "default"]
+        });
+      }
+    }
+  }
+  return results;
+};
+export {
+  serverVariables
+};

package/dist/rules/shared/tags-unique.d.ts

@@ -0,0 +1,7 @@
+import type { RulesetFunction } from '../../core/types.js';
+/**
+ * Flags duplicate tag names within one tags array. Both specs carry Tag Objects
+ * with a `name`, and both require those names to be unique within the array they
+ * sit in — see `oasTagsUnique` and `aasTagsUnique`.
+ */
+export declare const tagsUnique: RulesetFunction;

package/dist/rules/shared/tags-unique.js

@@ -0,0 +1,19 @@
+import { isObject } from "./helpers.js";
+const tagsUnique = (tags, _options, context) => {
+  if (!Array.isArray(tags))
+    return [];
+  const seen = /* @__PURE__ */ new Set();
+  const results = [];
+  tags.forEach((tag, index) => {
+    if (!isObject(tag) || typeof tag["name"] !== "string")
+      return;
+    if (seen.has(tag["name"])) {
+      results.push({ message: `Duplicate tag name "${tag["name"]}"`, path: [...context.path, index, "name"] });
+    }
+    seen.add(tag["name"]);
+  });
+  return results;
+};
+export {
+  tagsUnique
+};

package/dist/ruleset-files.d.ts

@@ -0,0 +1,47 @@
+import type { ResolvedExtend } from './core/index.js';
+import type { FunctionRegistry, RulesetDefinition, RulesetFunction } from './core/types.js';
+/**
+ * An optional directory that everything a ruleset pulls off disk — `extends`
+ * targets and custom function modules — must resolve inside.
+ *
+ * This is opt-in and off by default, because `basePath` on its own is only a
+ * *resolution origin*: an `extends` of `/etc/thing.js` or `../../../elsewhere`
+ * resolves and loads exactly as written. See the "Trust boundary" section of the
+ * README — a ruleset that can name a `.js` file can run code, restricted root or
+ * not. This narrows *which* files it can name; it is not a sandbox.
+ */
+export type IRulesetTrustOptions = {
+    /** Directory that `extends` files and custom functions must resolve under. */
+    restrictTo?: string;
+};
+/** Enforces {@link IRulesetTrustOptions.restrictTo}, if one was configured, on a resolved file path. */
+export declare const assertWithinRoot: (file: string, restrictTo: string | undefined, what: string) => void;
+/** Loads a ruleset definition from a file path by extension (YAML/JSON parsed, JS/CJS/MJS required). */
+export declare const loadRulesetFile: (file: string) => RulesetDefinition;
+/**
+ * Resolves an `extends` reference that names a file or an npm package:
+ * - local file paths (relative to `basePath`, or absolute): `.yaml` / `.yml` / `.json` / `.js`,
+ * - npm package specifiers (resolved from `basePath`), including subpaths.
+ *
+ * Callers that also recognize named presets (`@amritk/lint/rules/openapi` knows
+ * `oas`) check those first and only fall through to here.
+ */
+export declare const resolveRulesetFile: (name: string, basePath: string, options?: IRulesetTrustOptions) => ResolvedExtend;
+/** Loads a single custom function module (`<dir>/<name>.{js,cjs,mjs}` or a bare path). */
+export declare const loadFunctionByName: (basePath: string, dir: string, name: string, restrictTo: string | undefined) => RulesetFunction;
+/** How {@link collectCustomFunctions} follows a string `extends` target. */
+export type ICollectOptions = IRulesetTrustOptions & {
+    /**
+     * Resolves a string `extends` target to its definition and base directory.
+     * Return `undefined` for a name that is a built-in preset rather than a file —
+     * such a target has no directory of its own to load functions from.
+     */
+    resolveExtend: (name: string, basePath: string) => ResolvedExtend | undefined;
+};
+/**
+ * Walks a ruleset definition (and its string `extends`) collecting custom
+ * functions declared via `functions` / `functionsDir`, each loaded relative to
+ * the directory of the ruleset that declared it. YAML/JSON rulesets reference
+ * functions by name; JS rulesets can instead pass direct references in `then`.
+ */
+export declare const collectCustomFunctions: (definition: RulesetDefinition, basePath: string, into: FunctionRegistry, seen: Set<unknown>, options: ICollectOptions) => void;