@syv-ai/rulecast 0.1.1 → 0.2.0

package/dist/chunk-C6C5EER7.js

@@ -0,0 +1,1301 @@
+import {
+  CORE_VARIABLES,
+  DeadlineError,
+  LlmUnavailableError,
+  MODEL_ALIASES,
+  errorMessage,
+  isNotFound,
+  lineStarts,
+  offsetAt,
+  onPath,
+  perRule,
+  positionAt,
+  providerByName,
+  readSourceFile,
+  renderAgentText,
+  resolveModel
+} from "./chunk-ZEFEQKG5.js";
+
+// src/core/detection/registry.ts
+function createRegistry(detectors) {
+  const byKind = /* @__PURE__ */ new Map();
+  for (const detector of detectors) {
+    if (byKind.has(detector.kind)) throw new Error(`detector "${detector.kind}" registered twice`);
+    byKind.set(detector.kind, detector);
+  }
+  return {
+    get: (kind) => byKind.get(kind),
+    kinds: () => [...byKind.keys()]
+  };
+}
+
+// src/detectors/ast-grep/languages.ts
+var LANGUAGES = {
+  css: { builtin: "Css" },
+  html: { builtin: "Html" },
+  javascript: { builtin: "JavaScript" },
+  python: { load: () => import("@ast-grep/lang-python") },
+  tsx: { builtin: "Tsx" },
+  typescript: { builtin: "TypeScript" }
+};
+var LANGUAGE_NAMES = Object.keys(LANGUAGES);
+function napiLanguage(language) {
+  const entry = LANGUAGES[language];
+  return "builtin" in entry ? entry.builtin : language;
+}
+
+// src/detectors/ast-grep/load.ts
+var loading = null;
+async function load() {
+  loading ??= (async () => {
+    const napi = await import("@ast-grep/napi");
+    const dynamic = {};
+    for (const [name, entry] of Object.entries(LANGUAGES)) {
+      if (!("load" in entry)) continue;
+      const module = await entry.load();
+      dynamic[name] = module.default ?? module;
+    }
+    if (Object.keys(dynamic).length > 0) napi.registerDynamicLanguage(dynamic);
+    return napi;
+  })();
+  return loading;
+}
+var AstGrepUnavailable = class extends Error {
+  constructor(cause) {
+    super(`ast-grep is unavailable: ${errorMessage(cause)}`);
+  }
+};
+async function parserFor(language) {
+  let napi;
+  try {
+    napi = await load();
+  } catch (error) {
+    loading = null;
+    throw new AstGrepUnavailable(error);
+  }
+  const name = napiLanguage(language);
+  return { parse: (source) => napi.parse(name, source) };
+}
+
+// src/detectors/ast-grep/metavars.ts
+var METAVARIABLE = /\$\$\$([A-Z_][A-Z0-9_]*)|\$([A-Z_][A-Z0-9_]*)/g;
+function scan(value, into) {
+  if (typeof value === "string") {
+    for (const found of value.matchAll(METAVARIABLE)) {
+      const multi = found[1] !== void 0;
+      const name = found[1] ?? found[2];
+      if (name.startsWith("_")) continue;
+      into.set(name, (into.get(name) ?? false) || multi);
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) scan(item, into);
+    return;
+  }
+  if (typeof value === "object" && value !== null) {
+    for (const item of Object.values(value)) scan(item, into);
+  }
+}
+function metavariables(config) {
+  const found = /* @__PURE__ */ new Map();
+  scan(config, found);
+  return [...found].map(([name, multi]) => ({ name, multi }));
+}
+
+// src/detectors/ast-grep/schema.ts
+import { z } from "zod";
+var ruleObject = z.record(z.unknown()).refine((rule) => Object.keys(rule).length > 0, "rule must not be empty");
+var astGrepSchema = z.object({
+  language: z.enum(LANGUAGE_NAMES),
+  rule: ruleObject,
+  constraints: z.record(ruleObject).optional(),
+  utils: z.record(ruleObject).optional()
+}).strict().superRefine(async (config, ctx) => {
+  try {
+    const parser = await parserFor(config.language);
+    parser.parse("").root().findAll(matcher(config));
+  } catch (error) {
+    ctx.addIssue({ code: "custom", path: ["rule"], message: oneLine(errorMessage(error)) });
+  }
+});
+function oneLine(message) {
+  return message.split("\n").map((line) => line.replace(/^\s*\|->\s*/, "").trim()).filter(Boolean).join(" ");
+}
+function matcher(config) {
+  const { language: _language, ...rest } = config;
+  return rest;
+}
+function captureNames(config) {
+  return metavariables(matcher(config)).map((variable) => variable.name);
+}
+
+// src/detectors/ast-grep/detector.ts
+function capturesOf(node, variables) {
+  const captures = {};
+  for (const variable of variables) {
+    captures[variable.name] = variable.multi ? node.getMultipleMatches(variable.name).filter((match) => match.isNamed()).map((match) => match.text()).join(", ") : node.getMatch(variable.name)?.text() ?? "";
+  }
+  return captures;
+}
+function matchOf(file, node, variables) {
+  const range = node.range();
+  return {
+    file,
+    line: range.start.line + 1,
+    endLine: range.end.line + 1,
+    column: range.start.column + 1,
+    text: node.text(),
+    captures: capturesOf(node, variables)
+  };
+}
+var astGrepDetector = {
+  kind: "ast-grep",
+  schema: astGrepSchema,
+  captures: captureNames,
+  events: () => ["edit", "verify"],
+  guards: true,
+  async run(input) {
+    const result = { findings: [], errors: [] };
+    const byLanguage = /* @__PURE__ */ new Map();
+    for (const rule of input.rules) {
+      byLanguage.set(rule.config.language, [...byLanguage.get(rule.config.language) ?? [], rule]);
+    }
+    await Promise.all(
+      [...byLanguage].map(async ([language, rules]) => {
+        let parser;
+        try {
+          parser = await parserFor(language);
+        } catch (error) {
+          for (const rule of rules) result.errors.push({ rule: rule.id, message: errorMessage(error) });
+          return;
+        }
+        const variables = new Map(rules.map((rule) => [rule.id, metavariables(matcher(rule.config))]));
+        const files = [...new Set(rules.flatMap((rule) => rule.files))].sort();
+        for (const file of files) {
+          input.signal.throwIfAborted();
+          let root;
+          try {
+            const source = await input.read(file);
+            if (source === null) continue;
+            root = parser.parse(source).root();
+          } catch (error) {
+            if (input.signal.aborted) throw error;
+            const message = errorMessage(error);
+            for (const rule of rules) {
+              if (rule.files.includes(file) && !result.errors.some((existing) => existing.rule === rule.id)) {
+                result.errors.push({ rule: rule.id, message });
+              }
+            }
+            continue;
+          }
+          for (const rule of rules) {
+            if (!rule.files.includes(file)) continue;
+            try {
+              for (const node of root.findAll(matcher(rule.config))) {
+                result.findings.push({ rule: rule.id, match: matchOf(file, node, variables.get(rule.id)) });
+              }
+            } catch (error) {
+              if (input.signal.aborted) throw error;
+              if (!result.errors.some((existing) => existing.rule === rule.id)) {
+                result.errors.push({ rule: rule.id, message: errorMessage(error) });
+              }
+            }
+          }
+        }
+      })
+    );
+    return result;
+  },
+  async check(input) {
+    const languages = [...new Set(input.rules.map((rule) => rule.config.language))].sort();
+    for (const language of languages) await parserFor(language);
+    return [{ what: "ast-grep", level: "ok", detail: languages.join(", "), rules: [] }];
+  }
+};
+
+// src/detectors/command/detector.ts
+import { execFile } from "child_process";
+import { access, constants } from "fs/promises";
+import path2 from "path";
+import { promisify } from "util";
+
+// src/detectors/command/results.ts
+import { realpathSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function parseJson(output) {
+  try {
+    return JSON.parse(output);
+  } catch {
+    throw new Error("output is not JSON");
+  }
+}
+function repoRelative(file, cwd) {
+  const withoutScheme = file.startsWith("file://") ? fileURLToPath(file) : file;
+  if (!path.isAbsolute(withoutScheme)) return withoutScheme.split(path.sep).join("/");
+  for (const root of rootsOf(cwd)) {
+    const relative = path.relative(root, withoutScheme);
+    if (!relative.startsWith("..") && !path.isAbsolute(relative)) return relative.split(path.sep).join("/");
+  }
+  return path.relative(cwd, withoutScheme).split(path.sep).join("/");
+}
+function rootsOf(root) {
+  try {
+    const real = realpathSync(root);
+    return real === root ? [root] : [root, real];
+  } catch {
+    return [root];
+  }
+}
+function capturesOf2(source, names, where) {
+  const captures = {};
+  for (const name of names) {
+    const value = source[name];
+    if (typeof value !== "string") throw new Error(`${where}: capture "${name}" is not a string`);
+    captures[name] = value;
+  }
+  return captures;
+}
+function matchesFromJson(output, captures, cwd) {
+  const parsed = parseJson(output);
+  if (!Array.isArray(parsed)) throw new Error("output is not a JSON array of results");
+  return parsed.map((result, index) => {
+    const where = `result ${index + 1}`;
+    if (!isObject(result)) throw new Error(`${where}: not an object`);
+    if (typeof result.file !== "string") throw new Error(`${where}: "file" must be a string`);
+    if (typeof result.line !== "number") throw new Error(`${where}: "line" must be a number`);
+    return {
+      file: repoRelative(result.file, cwd),
+      line: result.line,
+      endLine: typeof result.endLine === "number" ? result.endLine : result.line,
+      column: typeof result.column === "number" ? result.column : 1,
+      text: typeof result.text === "string" ? result.text : "",
+      captures: capturesOf2(result, captures, where)
+    };
+  });
+}
+function matchesFromSarif(output, captures, cwd) {
+  const parsed = parseJson(output);
+  if (!isObject(parsed) || !Array.isArray(parsed.runs)) throw new Error("output is not SARIF 2.1.0");
+  const matches = [];
+  let index = 0;
+  for (const run of parsed.runs) {
+    if (!isObject(run) || !Array.isArray(run.results)) throw new Error("output is not SARIF 2.1.0");
+    for (const result of run.results) {
+      index += 1;
+      const where = `result ${index}`;
+      if (!isObject(result)) throw new Error(`${where}: not an object`);
+      const location = Array.isArray(result.locations) ? result.locations[0] : void 0;
+      const physical = isObject(location) ? location.physicalLocation : void 0;
+      const artifact = isObject(physical) ? physical.artifactLocation : void 0;
+      if (!isObject(artifact) || typeof artifact.uri !== "string") continue;
+      const region = isObject(physical) && isObject(physical.region) ? physical.region : {};
+      const line = typeof region.startLine === "number" ? region.startLine : 1;
+      const message = isObject(result.message) && typeof result.message.text === "string" ? result.message.text : "";
+      const source = isObject(result.properties) ? { ...result, ...result.properties } : result;
+      matches.push({
+        file: repoRelative(artifact.uri, cwd),
+        line,
+        endLine: typeof region.endLine === "number" ? region.endLine : line,
+        column: typeof region.startColumn === "number" ? region.startColumn : 1,
+        text: message,
+        captures: capturesOf2(source, captures, where)
+      });
+    }
+  }
+  return matches;
+}
+
+// src/detectors/command/schema.ts
+import { z as z2 } from "zod";
+var VARIABLE_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var commandSchema = z2.object({
+  /** argv. The element exactly "{{files}}" is replaced by the rule's files; otherwise they are appended. */
+  run: z2.array(z2.string().min(1)).min(1),
+  output: z2.enum(["json", "sarif"]).default("json"),
+  captures: z2.array(z2.string().regex(VARIABLE_NAME, "a capture must be a template variable name")).default([]).superRefine((captures, ctx) => {
+    for (const name of captures) {
+      if (CORE_VARIABLES.includes(name)) {
+        ctx.addIssue({ code: "custom", message: `"${name}" is a core template variable` });
+      }
+    }
+  })
+}).strict();
+
+// src/detectors/command/detector.ts
+var exec = promisify(execFile);
+var FILES = "{{files}}";
+function argvFor(run, files) {
+  if (!run.includes(FILES)) return [...run, ...files];
+  return run.flatMap((argument) => argument === FILES ? files : [argument]);
+}
+async function reachable(command, cwd, signal) {
+  if (!command.includes("/")) {
+    return await onPath(command, signal) ? { level: "ok", detail: `${command} (PATH)` } : { level: "error", detail: "not installed" };
+  }
+  const full = path2.resolve(cwd, command);
+  try {
+    await access(full, constants.F_OK);
+  } catch {
+    return { level: "error", detail: "no such file" };
+  }
+  try {
+    await access(full, constants.X_OK);
+  } catch {
+    return { level: "error", detail: "not executable" };
+  }
+  return { level: "ok", detail: full };
+}
+var commandDetector = {
+  kind: "command",
+  schema: commandSchema,
+  captures: (config) => config.captures,
+  events: () => ["edit", "verify"],
+  run: perRule(async (rule, input) => {
+    if (rule.files.length === 0) return [];
+    const [command, ...rest] = argvFor(rule.config.run, rule.files);
+    let stdout;
+    try {
+      const result = await exec(command, rest, { cwd: input.cwd, signal: input.signal, maxBuffer: 64 * 1024 * 1024 });
+      stdout = result.stdout;
+    } catch (error) {
+      if (input.signal.aborted) throw error;
+      if (isNotFound(error)) throw new Error(`command not found: ${command}`);
+      const failure = error;
+      if (typeof failure.stdout !== "string") throw error;
+      stdout = failure.stdout;
+    }
+    return rule.config.output === "sarif" ? matchesFromSarif(stdout, rule.config.captures, input.cwd) : matchesFromJson(stdout, rule.config.captures, input.cwd);
+  }),
+  async check(input) {
+    const byCommand = /* @__PURE__ */ new Map();
+    for (const rule of input.rules) {
+      const command = rule.config.run[0];
+      byCommand.set(command, [...byCommand.get(command) ?? [], rule.id]);
+    }
+    return Promise.all(
+      [...byCommand].map(async ([command, rules]) => {
+        const { level, detail } = await reachable(command, input.cwd, input.signal);
+        return { what: command, level, detail, rules: level === "ok" ? [] : rules };
+      })
+    );
+  }
+};
+
+// src/detectors/linter/detector.ts
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+
+// src/detectors/linter/resolve.ts
+import { access as access2, constants as constants2 } from "fs/promises";
+import path3 from "path";
+var PYTHON_TOOLS = /* @__PURE__ */ new Set(["ruff"]);
+async function reachable2(file, mode) {
+  try {
+    await access2(file, mode);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveTool(tool, root, available = onPath) {
+  const local = path3.join(root, "node_modules", ".bin", tool);
+  if (await reachable2(local, constants2.X_OK)) return { command: local, prefix: [] };
+  if (PYTHON_TOOLS.has(tool) && await reachable2(path3.join(root, "pyproject.toml"), constants2.F_OK) && await available("uv")) {
+    return { command: "uv", prefix: ["run", "--", tool] };
+  }
+  return { command: tool, prefix: [] };
+}
+async function describeTool(tool, root, options = {}) {
+  const available = options.available ?? ((command) => onPath(command, options.signal));
+  const resolved = await resolveTool(tool, root, available);
+  if (path3.isAbsolute(resolved.command)) {
+    const relative = path3.relative(root, resolved.command);
+    const inside = relative !== "" && !relative.startsWith("..") && !path3.isAbsolute(relative);
+    return { command: inside ? relative.split(path3.sep).join("/") : resolved.command, how: "local", found: true };
+  }
+  if (resolved.prefix.length > 0) {
+    return { command: [resolved.command, ...resolved.prefix].join(" "), how: "uv", found: true };
+  }
+  return { command: resolved.command, how: "path", found: await available(resolved.command) };
+}
+
+// src/detectors/linter/schema.ts
+import { z as z3 } from "zod";
+var TOOL_NAMES = ["eslint", "oxlint", "ruff"];
+var linterSchema = z3.object({
+  tool: z3.enum(TOOL_NAMES),
+  /** Linter rule ids to report. Omitted: every finding the tool reports. */
+  rules: z3.array(z3.string().min(1)).min(1).optional()
+}).strict();
+
+// src/detectors/linter/tools.ts
+import { realpathSync as realpathSync2 } from "fs";
+import path4 from "path";
+var isObject2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function json(tool, stdout) {
+  try {
+    return JSON.parse(stdout);
+  } catch {
+    throw new Error(`${tool} output is not JSON`);
+  }
+}
+function relativeTo(roots, file) {
+  if (!path4.isAbsolute(file)) return file.split(path4.sep).join("/");
+  for (const root of roots) {
+    const relative = path4.relative(root, file);
+    if (!relative.startsWith("..") && !path4.isAbsolute(relative)) return relative.split(path4.sep).join("/");
+  }
+  return path4.relative(roots[0], file).split(path4.sep).join("/");
+}
+function rootsOf2(root) {
+  try {
+    const real = realpathSync2(root);
+    return real === root ? [root] : [root, real];
+  } catch {
+    return [root];
+  }
+}
+var number = (value, fallback) => typeof value === "number" ? value : fallback;
+var text = (value) => typeof value === "string" ? value : "";
+function oxlintRuleId(code) {
+  const raw = text(code);
+  return /^[\w-]+\((?<rule>[^)]+)\)$/.exec(raw)?.groups?.rule ?? raw;
+}
+var TOOLS = {
+  ruff: {
+    events: ["edit", "verify"],
+    args: (files) => ["check", "--output-format", "json", "--force-exclude", "--", ...files],
+    parse(stdout, root) {
+      const parsed = json("ruff", stdout);
+      if (!Array.isArray(parsed)) throw new Error("ruff output is not a JSON array of diagnostics");
+      const roots = rootsOf2(root);
+      return parsed.filter(isObject2).map((result) => {
+        const start = isObject2(result.location) ? result.location : {};
+        const end = isObject2(result.end_location) ? result.end_location : {};
+        const line = number(start.row, 1);
+        return {
+          file: relativeTo(roots, text(result.filename)),
+          line,
+          column: number(start.column, 1),
+          endLine: number(end.row, line),
+          endColumn: typeof end.column === "number" ? end.column : null,
+          ruleId: text(result.code),
+          message: text(result.message)
+        };
+      });
+    }
+  },
+  oxlint: {
+    events: ["edit", "verify"],
+    args: (files) => ["--format=json", "--", ...files],
+    parse(stdout, root) {
+      const parsed = json("oxlint", stdout);
+      if (!isObject2(parsed) || !Array.isArray(parsed.diagnostics)) {
+        throw new Error("oxlint output is not JSON with diagnostics");
+      }
+      const roots = rootsOf2(root);
+      return parsed.diagnostics.filter(isObject2).map((diagnostic) => {
+        const label = Array.isArray(diagnostic.labels) ? diagnostic.labels[0] : void 0;
+        const span = isObject2(label) && isObject2(label.span) ? label.span : {};
+        const line = number(span.line, 1);
+        return {
+          file: relativeTo(roots, text(diagnostic.filename)),
+          line,
+          column: number(span.column, 1),
+          endLine: line,
+          endColumn: null,
+          ruleId: oxlintRuleId(diagnostic.code),
+          message: text(diagnostic.message)
+        };
+      });
+    }
+  },
+  eslint: {
+    // eslint is the slow one: spec §6 keeps it off the edit hook by default.
+    events: ["verify"],
+    args: (files) => ["--format=json", "--no-error-on-unmatched-pattern", "--", ...files],
+    parse(stdout, root) {
+      const parsed = json("eslint", stdout);
+      if (!Array.isArray(parsed)) throw new Error("eslint output is not a JSON array of file results");
+      const roots = rootsOf2(root);
+      const findings = [];
+      for (const file of parsed.filter(isObject2)) {
+        const messages = Array.isArray(file.messages) ? file.messages : [];
+        for (const message of messages.filter(isObject2)) {
+          const line = number(message.line, 1);
+          findings.push({
+            file: relativeTo(roots, text(file.filePath)),
+            line,
+            column: number(message.column, 1),
+            endLine: number(message.endLine, line),
+            endColumn: typeof message.endColumn === "number" ? message.endColumn : null,
+            ruleId: text(message.ruleId),
+            message: text(message.message)
+          });
+        }
+      }
+      return findings;
+    }
+  }
+};
+
+// src/detectors/linter/detector.ts
+var exec2 = promisify2(execFile2);
+function sourceReader(cwd) {
+  const cache = /* @__PURE__ */ new Map();
+  return (file) => {
+    let source = cache.get(file);
+    if (source === void 0) {
+      source = readSourceFile(cwd, file);
+      cache.set(file, source);
+    }
+    return source;
+  };
+}
+function excerpt(source, finding) {
+  if (source === null) return "";
+  const starts = lineStarts(source);
+  const from = offsetAt(starts, finding.line, finding.column, source.length);
+  let to;
+  if (finding.endColumn === null) {
+    const newline = source.indexOf("\n", from);
+    to = newline === -1 ? source.length : newline;
+  } else {
+    to = offsetAt(starts, finding.endLine, finding.endColumn, source.length);
+  }
+  return source.slice(from, Math.max(from, to)).replace(/\n$/, "");
+}
+async function runTool(tool, files, cwd, signal) {
+  const resolved = await resolveTool(tool, cwd);
+  const args = [...resolved.prefix, ...TOOLS[tool].args(files)];
+  let stdout;
+  try {
+    const result = await exec2(resolved.command, args, { cwd, signal, maxBuffer: 64 * 1024 * 1024 });
+    stdout = result.stdout;
+  } catch (error) {
+    if (signal.aborted) throw error;
+    if (isNotFound(error)) throw new Error(`${tool} is not installed`);
+    const failure = error;
+    if (typeof failure.stdout !== "string") throw error;
+    stdout = failure.stdout;
+  }
+  return TOOLS[tool].parse(stdout, cwd);
+}
+var linterDetector = {
+  kind: "linter",
+  schema: linterSchema,
+  captures: () => ["message", "ruleId"],
+  // A copy: compileRule stores this as the rule's stages, and module-level data must not escape into it.
+  events: (config) => [...TOOLS[config.tool].events],
+  async run(input) {
+    const result = { findings: [], errors: [] };
+    const byTool = /* @__PURE__ */ new Map();
+    for (const rule of input.rules) {
+      byTool.set(rule.config.tool, [...byTool.get(rule.config.tool) ?? [], rule]);
+    }
+    const read = sourceReader(input.cwd);
+    await Promise.all(
+      [...byTool].map(async ([tool, rules]) => {
+        const files = [...new Set(rules.flatMap((rule) => rule.files))].sort();
+        if (files.length === 0) return;
+        try {
+          const findings = await runTool(tool, files, input.cwd, input.signal);
+          for (const finding of findings) {
+            const match = {
+              file: finding.file,
+              line: finding.line,
+              endLine: finding.endLine,
+              column: finding.column,
+              text: excerpt(await read(finding.file), finding),
+              captures: { message: finding.message, ruleId: finding.ruleId }
+            };
+            for (const rule of rules) {
+              if (!rule.files.includes(finding.file)) continue;
+              if (rule.config.rules && !rule.config.rules.includes(finding.ruleId)) continue;
+              result.findings.push({ rule: rule.id, match });
+            }
+          }
+        } catch (error) {
+          if (input.signal.aborted) throw error;
+          const message = errorMessage(error);
+          for (const rule of rules) result.errors.push({ rule: rule.id, message });
+        }
+      })
+    );
+    return result;
+  },
+  async check(input) {
+    const byTool = /* @__PURE__ */ new Map();
+    for (const rule of input.rules) {
+      byTool.set(rule.config.tool, [...byTool.get(rule.config.tool) ?? [], rule.id]);
+    }
+    return Promise.all(
+      [...byTool].map(async ([tool, rules]) => {
+        const described = await describeTool(tool, input.cwd, { signal: input.signal });
+        if (!described.found) return { what: tool, level: "error", detail: "not installed", rules };
+        const detail = described.how === "path" ? `${described.command} (PATH)` : described.command;
+        return { what: tool, level: "ok", detail, rules: [] };
+      })
+    );
+  }
+};
+
+// src/detectors/llm/call.ts
+import { createHash } from "crypto";
+function callKey(input) {
+  const payload = {
+    file: input.file,
+    source: input.source,
+    changedLines: input.changedLines,
+    provider: input.provider,
+    baseUrl: input.baseUrl,
+    model: input.model,
+    rules: [...input.rules].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0).map((rule) => ({ id: rule.id, config: rule.config, grounding: rule.grounding }))
+  };
+  return createHash("sha256").update(JSON.stringify(payload)).digest("hex");
+}
+async function askCached(provider, cache, key, request) {
+  const cached = await cache.get(key);
+  if (cached !== void 0) return cached;
+  const findings = await provider.ask(request);
+  await cache.set(key, findings);
+  return findings;
+}
+
+// src/detectors/llm/prompt.ts
+function buildPrompt(call) {
+  const marked = call.changedLines !== null;
+  const lines = [
+    "Check the file below against each rule. Report every line that breaks a rule.",
+    "",
+    'Answer with JSON only: {"findings": [{"rule": "<rule id>", "line": <number>, "text": "<the line>", "reason": "<why>"}]}',
+    "Report nothing when a rule is not broken. Use the rule ids exactly as given.",
+    marked ? 'Only lines marked with ">" were changed. Report findings on those lines only.' : "Judge the whole file.",
+    "",
+    "## Rules",
+    ""
+  ];
+  for (const rule of call.rules) {
+    lines.push(`### ${rule.id}`, rule.question, "");
+    for (const reference of rule.grounding) {
+      lines.push(`Reference \u2014 ${reference.ref}:`, '"""', reference.content.replace(/\n$/, ""), '"""', "");
+    }
+  }
+  lines.push(`## File: ${call.file}`, "");
+  const fence = fenceFor(call.source);
+  lines.push(fence, ...numbered(call.source, call.changedLines), fence);
+  return lines.join("\n");
+}
+function fenceFor(source) {
+  let longest = 2;
+  for (const run of source.match(/`+/g) ?? []) longest = Math.max(longest, run.length);
+  return "`".repeat(longest + 1);
+}
+function numbered(source, changedLines) {
+  const sourceLines = source.replace(/\n$/, "").split("\n");
+  const width = String(sourceLines.length).length;
+  return sourceLines.map((text2, index) => {
+    const number2 = index + 1;
+    const mark = changedLines !== null && isChanged(number2, changedLines) ? "> " : "  ";
+    return `${mark}${String(number2).padStart(width)}  ${text2}`;
+  });
+}
+function isChanged(line, changedLines) {
+  return changedLines.some(([start, end]) => line >= start && line <= end);
+}
+
+// src/detectors/llm/schema.ts
+import { z as z4 } from "zod";
+var llmSchema = z4.object({
+  /**
+   * An alias from ./models.ts — haiku, sonnet, opus, fable — or the exact name the configured
+   * provider uses. Required: there is no project-wide default, so the cost of a rule is always
+   * chosen by whoever wrote it (plan 6a, Decision 1).
+   */
+  model: z4.string().trim().min(1),
+  question: z4.string().trim().min(1),
+  /** Send the rule's resolved context references with the question, whatever their delivery mode. */
+  grounding: z4.boolean().default(true)
+}).strict();
+
+// src/detectors/llm/detector.ts
+function sourceReader2(cwd) {
+  const cache = /* @__PURE__ */ new Map();
+  return (file) => {
+    let source = cache.get(file);
+    if (source === void 0) {
+      source = readSourceFile(cwd, file);
+      cache.set(file, source);
+    }
+    return source;
+  };
+}
+function changedLinesOf(changes, file) {
+  const change = changes.get(file);
+  if (change === void 0) return null;
+  return change.changedLines.length === 0 ? "skip" : change.changedLines;
+}
+async function groupCalls(rules, changes, read) {
+  const calls = /* @__PURE__ */ new Map();
+  for (const rule of rules) {
+    for (const file of rule.files) {
+      const changedLines = changedLinesOf(changes, file);
+      if (changedLines === "skip") continue;
+      const source = await read(file);
+      if (source === null) continue;
+      const key = `${file}\0${rule.config.model}`;
+      const call = calls.get(key);
+      if (call) call.rules.push(rule);
+      else calls.set(key, { file, source, changedLines, model: rule.config.model, rules: [rule] });
+    }
+  }
+  return [...calls.values()];
+}
+function promptRules(rules) {
+  return rules.map((rule) => ({
+    id: rule.id,
+    question: rule.config.question,
+    // Spec §6: the rule's resolved references, whatever their delivery mode.
+    grounding: rule.config.grounding ? rule.context.map((ref) => ({ ref: ref.ref, content: ref.content })) : []
+  }));
+}
+function toFindings(call, answered) {
+  const lines = call.source.replace(/\n$/, "").split("\n");
+  const ids = new Set(call.rules.map((rule) => rule.id));
+  const findings = [];
+  for (const finding of answered) {
+    if (!ids.has(finding.rule)) continue;
+    if (finding.line < 1 || finding.line > lines.length) continue;
+    if (call.changedLines !== null && !call.changedLines.some(([a, b]) => finding.line >= a && finding.line <= b)) {
+      continue;
+    }
+    findings.push({
+      rule: finding.rule,
+      match: {
+        file: call.file,
+        line: finding.line,
+        endLine: finding.line,
+        column: 1,
+        // The file's own line, not the model's quote: {{text}} is the matched source everywhere else.
+        text: lines[finding.line - 1],
+        captures: { reason: finding.reason }
+      }
+    });
+  }
+  return findings;
+}
+function unmappedModel(provider) {
+  return `no name for the ${provider} provider; use that provider's own model name`;
+}
+async function runCall(call, provider, settings, input) {
+  const model = resolveModel(call.model, settings.provider);
+  if (model === null) throw new Error(`model "${call.model}" has ${unmappedModel(settings.provider)}`);
+  const rules = promptRules(call.rules);
+  const key = callKey({
+    file: call.file,
+    source: call.source,
+    changedLines: call.changedLines,
+    provider: settings.provider,
+    baseUrl: settings.baseUrl,
+    model,
+    rules: call.rules.map((rule, index) => ({
+      id: rule.id,
+      config: rule.config,
+      grounding: rules[index].grounding
+    }))
+  });
+  const answered = await askCached(provider, input.cache, key, {
+    model,
+    prompt: buildPrompt({ file: call.file, source: call.source, changedLines: call.changedLines, rules }),
+    settings,
+    env: process.env,
+    cwd: input.cwd,
+    signal: input.signal
+  });
+  return toFindings(call, answered);
+}
+var llmDetector = {
+  kind: "llm",
+  schema: llmSchema,
+  captures: () => ["reason"],
+  // verify only by default (spec §6): a model call is far too slow for an edit hook. A rule opts
+  // in with `stages: [edit, verify]`.
+  events: () => ["verify"],
+  async run(input) {
+    const result = { findings: [], errors: [] };
+    const settings = input.settings.llm;
+    let provider;
+    try {
+      provider = providerByName(settings.provider);
+    } catch (error) {
+      return { findings: [], errors: [{ rule: null, message: errorMessage(error) }] };
+    }
+    const calls = await groupCalls(input.rules, input.changes, sourceReader2(input.cwd));
+    const outcomes = await Promise.all(
+      calls.map(async (call) => {
+        try {
+          return { call, findings: await runCall(call, provider, settings, input) };
+        } catch (error) {
+          if (input.signal.aborted) throw error;
+          return { call, error };
+        }
+      })
+    );
+    for (const outcome of outcomes) {
+      if ("error" in outcome && outcome.error instanceof LlmUnavailableError) {
+        return { findings: [], errors: [{ rule: null, message: outcome.error.message }] };
+      }
+    }
+    for (const outcome of outcomes) {
+      if ("error" in outcome) {
+        const message = errorMessage(outcome.error);
+        for (const rule of outcome.call.rules) result.errors.push({ rule: rule.id, message });
+        continue;
+      }
+      result.findings.push(...outcome.findings);
+    }
+    return result;
+  },
+  /**
+   * The two pre-flight checks plan 6a deferred here: is the backend reachable at all, and does
+   * every rule's model alias have a name for it. Both are environmental and free — nothing in this
+   * method calls a model, which is also why doctor does not dry-run llm rules.
+   */
+  async check(input) {
+    const settings = input.settings.llm;
+    const ids = input.rules.map((rule) => rule.id);
+    let provider;
+    try {
+      provider = providerByName(settings.provider);
+    } catch (error) {
+      return [{ what: settings.provider, level: "error", detail: errorMessage(error), rules: ids }];
+    }
+    const reachable3 = await provider.available({
+      settings,
+      env: input.env,
+      cwd: input.cwd,
+      signal: input.signal
+    });
+    const results = [
+      {
+        what: settings.provider,
+        level: reachable3.ok ? "ok" : "error",
+        detail: reachable3.detail,
+        rules: reachable3.ok ? [] : ids
+      }
+    ];
+    const byModel = /* @__PURE__ */ new Map();
+    for (const rule of input.rules) {
+      byModel.set(rule.config.model, [...byModel.get(rule.config.model) ?? [], rule.id]);
+    }
+    for (const [model, rules] of byModel) {
+      const resolved = resolveModel(model, settings.provider);
+      results.push(
+        resolved === null ? {
+          what: `model "${model}"`,
+          level: "error",
+          detail: unmappedModel(settings.provider),
+          rules
+        } : {
+          what: `model "${model}"`,
+          level: "ok",
+          // "passed through" is only true of a name that is not an alias at all. An alias that
+          // resolves to itself — haiku for the claude-code provider — is still an alias, and
+          // saying otherwise reads as "rulecast does not know this model".
+          detail: MODEL_ALIASES.includes(model) ? `${settings.provider} calls it ${resolved}` : "passed through",
+          rules: []
+        }
+      );
+    }
+    return results;
+  }
+};
+
+// src/detectors/path.ts
+import { z as z5 } from "zod";
+var schema = z5.object({}).strict();
+var pathDetector = {
+  kind: "path",
+  schema,
+  captures: () => [],
+  events: () => ["edit", "verify"],
+  guards: true,
+  run: perRule(async (rule, input) => {
+    const matches = [];
+    for (const file of rule.files) {
+      input.signal.throwIfAborted();
+      const text2 = await input.read(file);
+      if (text2 === null) continue;
+      matches.push({ file, line: 1, endLine: text2.split(/\r?\n/).length, column: 1, text: file, captures: {} });
+    }
+    return matches;
+  })
+};
+
+// src/detectors/regex.ts
+import { createContext, Script } from "vm";
+import { z as z6 } from "zod";
+var schema2 = z6.object({
+  pattern: z6.string().min(1),
+  flags: z6.string().regex(/^[dimsuvy]*$/, "allowed flags: d i m s u v y").default("")
+}).strict().superRefine((config, ctx) => {
+  try {
+    new RegExp(config.pattern, config.flags);
+  } catch (error) {
+    ctx.addIssue({ code: "custom", path: ["pattern"], message: errorMessage(error) });
+  }
+});
+var NAMED_GROUP = /\(\?<([A-Za-z_$][\w$]*)>/g;
+function groupNames(pattern) {
+  return [...new Set([...pattern.matchAll(NAMED_GROUP)].map((match) => match[1]))];
+}
+var SCOPE = { text: null, res: null, out: null };
+var MATCH_CONTEXT = createContext(SCOPE);
+var MATCH_SCRIPT = new Script("out = res.map((re) => [...text.matchAll(re)])", {
+  filename: "rulecast-regex-match.js"
+});
+function matchAllWithin(text2, patterns, budgetMs) {
+  SCOPE.text = text2;
+  SCOPE.res = patterns;
+  SCOPE.out = null;
+  try {
+    MATCH_SCRIPT.runInContext(MATCH_CONTEXT, { timeout: Math.max(1, Math.trunc(budgetMs)) });
+    return SCOPE.out ?? [];
+  } catch (error) {
+    throw new DeadlineError(errorMessage(error));
+  } finally {
+    SCOPE.text = null;
+    SCOPE.res = null;
+    SCOPE.out = null;
+  }
+}
+var regexDetector = {
+  kind: "regex",
+  schema: schema2,
+  captures: (config) => groupNames(config.pattern),
+  events: () => ["edit", "verify"],
+  guards: true,
+  /**
+   * Driven by file rather than by rule, so one file is read once and scanned once however many
+   * rules select it. `perRule` would read and match it once per rule — 100,000 reads for 500 rules
+   * over 200 files — and there is nothing for `perRule` to isolate here: a pattern the schema
+   * accepted cannot fail at run time, which is why the contract fixture has no failing case.
+   */
+  async run(input) {
+    const result = { findings: [], errors: [] };
+    const names = new Map(input.rules.map((rule) => [rule.id, groupNames(rule.config.pattern)]));
+    const byFile = /* @__PURE__ */ new Map();
+    for (const rule of input.rules) {
+      for (const file of rule.files) {
+        const group = byFile.get(file);
+        if (group === void 0) byFile.set(file, [rule]);
+        else group.push(rule);
+      }
+    }
+    for (const [file, rules] of byFile) {
+      input.signal.throwIfAborted();
+      const text2 = await input.read(file);
+      if (text2 === null) continue;
+      const starts = lineStarts(text2);
+      const patterns = rules.map((rule) => new RegExp(rule.config.pattern, `${rule.config.flags}g`));
+      const perPattern = matchAllWithin(text2, patterns, input.deadlineAt - Date.now());
+      for (const [index, rule] of rules.entries()) {
+        const captured = names.get(rule.id) ?? [];
+        for (const found of perPattern[index] ?? []) {
+          const start = found.index;
+          const end = start + found[0].length;
+          const from = positionAt(starts, start);
+          const to = positionAt(starts, Math.max(start, end - 1));
+          result.findings.push({
+            rule: rule.id,
+            match: {
+              file,
+              line: from.line,
+              endLine: to.line,
+              column: from.column,
+              text: found[0],
+              captures: Object.fromEntries(captured.map((name) => [name, found.groups?.[name] ?? ""]))
+            }
+          });
+        }
+      }
+    }
+    return result;
+  }
+};
+
+// src/detectors/index.ts
+var builtinDetectors = [
+  regexDetector,
+  pathDetector,
+  astGrepDetector,
+  commandDetector,
+  linterDetector,
+  llmDetector
+];
+
+// src/adapters/claude-code/parse.ts
+import { z as z7 } from "zod";
+var common = z7.object({
+  hook_event_name: z7.string(),
+  session_id: z7.string().min(1),
+  cwd: z7.string().min(1),
+  agent_id: z7.string().min(1).optional(),
+  agent_type: z7.string().optional(),
+  source: z7.string().optional(),
+  prompt: z7.string().optional()
+});
+var fileTool = z7.object({
+  tool_name: z7.string(),
+  tool_input: z7.object({ file_path: z7.string().min(1) })
+});
+var readResponse = z7.object({
+  tool_response: z7.object({
+    file: z7.object({ startLine: z7.number(), numLines: z7.number(), totalLines: z7.number() })
+  })
+});
+var writeInput = z7.object({
+  tool_input: z7.object({
+    file_path: z7.string().min(1),
+    content: z7.string().optional(),
+    old_string: z7.string().optional(),
+    new_string: z7.string().optional(),
+    replace_all: z7.boolean().optional()
+  })
+});
+function parseClaudeCode(input) {
+  const head = common.safeParse(input);
+  if (!head.success) return null;
+  const {
+    hook_event_name: hook,
+    session_id: id,
+    cwd,
+    agent_id: agentId,
+    agent_type: agentType,
+    source,
+    prompt
+  } = head.data;
+  const session = agentId === void 0 ? { id } : { id, agentId };
+  const result = (kind, files = [], completeRead) => ({
+    cwd,
+    event: kind === null ? null : { kind, files, cwd, session, ...completeRead === void 0 ? {} : { completeRead } },
+    warmup: false
+  });
+  switch (hook) {
+    case "PreToolUse": {
+      const tool = fileTool.safeParse(input);
+      if (!tool.success) return result(null);
+      const { tool_name: name } = tool.data;
+      if (name !== "Edit" && name !== "Write") return result(null);
+      const write = writeInput.safeParse(input);
+      if (!write.success) return result(null);
+      const {
+        file_path: file,
+        content,
+        old_string: find,
+        new_string: replace,
+        replace_all: all
+      } = write.data.tool_input;
+      const intent = content !== void 0 ? { content } : find !== void 0 && replace !== void 0 ? { edit: { find, replace, all: all === true } } : null;
+      if (intent === null) return result(null);
+      return { ...result("guard", [file]), event: { kind: "guard", files: [file], cwd, session, intent } };
+    }
+    case "PostToolUse": {
+      const tool = fileTool.safeParse(input);
+      if (!tool.success) return result(null);
+      const { tool_name: name, tool_input: toolInput } = tool.data;
+      if (name === "Edit" || name === "Write") return result("edit", [toolInput.file_path]);
+      if (name !== "Read") return result(null);
+      const read = readResponse.safeParse(input);
+      const file = read.success ? read.data.tool_response.file : null;
+      return result(
+        "touch",
+        [toolInput.file_path],
+        file !== null && file.startLine === 1 && file.numLines === file.totalLines
+      );
+    }
+    case "Stop":
+      return result("verify");
+    case "SubagentStop":
+      return result(agentType === "" ? null : "verify");
+    case "UserPromptSubmit":
+      return result(prompt?.startsWith("<task-notification>") ? null : "prompt");
+    case "SessionStart":
+      if (source === "compact") return result("reset");
+      return { ...result(null), warmup: source === "startup" || source === "resume" };
+    default:
+      return result(null);
+  }
+}
+
+// src/adapters/claude-code/settings.ts
+var SettingsError = class extends Error {
+};
+var RULECAST_HOOK = /\brulecast\b.*\bhook claude-code\b/;
+var isObject3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRulecastHook = (hook) => isObject3(hook) && typeof hook.command === "string" && RULECAST_HOOK.test(hook.command);
+function hookGroups(verifyMs) {
+  const verifyTimeout = Math.ceil(verifyMs / 1e3) + 10;
+  return [
+    // Before the write, for refuse_write rules. It answers nothing at all unless the project has
+    // one, so the cost on an ordinary edit is starting rulecast and compiling the config.
+    { event: "PreToolUse", matcher: "Edit|Write", timeout: 5 },
+    { event: "PostToolUse", matcher: "Read", timeout: 5 },
+    { event: "PostToolUse", matcher: "Edit|Write", timeout: 5 },
+    { event: "Stop", timeout: verifyTimeout },
+    { event: "SubagentStop", timeout: verifyTimeout },
+    { event: "UserPromptSubmit", timeout: 5 },
+    { event: "SessionStart", matcher: "startup|resume|compact", timeout: 5 }
+  ];
+}
+function installed(groups, matcher2) {
+  return groups.some(
+    (group) => isObject3(group) && group.matcher === matcher2 && Array.isArray(group.hooks) && group.hooks.some(isRulecastHook)
+  );
+}
+function hooksOf(settings) {
+  if (!isObject3(settings)) throw new SettingsError("settings must be a JSON object");
+  const hooks = settings.hooks ?? {};
+  if (!isObject3(hooks)) throw new SettingsError('"hooks" must be an object');
+  return hooks;
+}
+function mergeHooks(settings, command, verifyMs) {
+  const merged = { ...hooksOf(settings) };
+  const added = [];
+  for (const { event, matcher: matcher2, timeout } of hookGroups(verifyMs)) {
+    const groups = merged[event] ?? [];
+    if (!Array.isArray(groups)) throw new SettingsError(`"hooks.${event}" must be an array`);
+    if (installed(groups, matcher2)) continue;
+    const hook = { type: "command", command, timeout };
+    merged[event] = [...groups, matcher2 === void 0 ? { hooks: [hook] } : { matcher: matcher2, hooks: [hook] }];
+    added.push(matcher2 === void 0 ? event : `${event} (${matcher2})`);
+  }
+  return { settings: { ...settings, hooks: merged }, added };
+}
+function removeHooks(settings) {
+  const hooks = hooksOf(settings);
+  const source = settings;
+  const kept = {};
+  const removed = [];
+  for (const [event, groups] of Object.entries(hooks)) {
+    if (!Array.isArray(groups)) throw new SettingsError(`"hooks.${event}" must be an array`);
+    const remaining = [];
+    for (const group of groups) {
+      if (!isObject3(group) || !Array.isArray(group.hooks) || !group.hooks.some(isRulecastHook)) {
+        remaining.push(group);
+        continue;
+      }
+      removed.push(typeof group.matcher === "string" ? `${event} (${group.matcher})` : event);
+      const others = group.hooks.filter((hook) => !isRulecastHook(hook));
+      if (others.length > 0) remaining.push({ ...group, hooks: others });
+    }
+    if (remaining.length > 0 || groups.length === 0) kept[event] = remaining;
+  }
+  if (removed.length === 0) return { settings: source, removed };
+  const result = {};
+  for (const [key, value] of Object.entries(source)) {
+    if (key !== "hooks") result[key] = value;
+    else if (Object.keys(kept).length > 0) result[key] = kept;
+  }
+  return { settings: result, removed };
+}
+
+// src/adapters/claude-code/adapter.ts
+var CONTEXT_LIMIT = 1e4;
+var CONTEXT_BUDGET = 9e3;
+var BLOCK_PREAMBLE = "This project's rulecast rules (.rulecast-config.yaml) found problems in code changed in this session. Fix them before you finish.";
+var CAP_PREAMBLE = "rulecast: the agent stopped with these findings unresolved (stop gate limit reached).";
+var DENY_PREAMBLE = "This project's rulecast rules (.rulecast-config.yaml) refuse this write. Change what you are writing, or the file you are writing it to, and try again.";
+function cutNotice(delivery, event) {
+  if (delivery.overflowPath !== null) {
+    return `
+
+\u2026cut to fit Claude Code's hook output limit. The whole delivery is in ${delivery.overflowPath}.`;
+  }
+  const session = event.session ? `--session ${event.session.id} ` : "";
+  return `
+
+\u2026cut to fit Claude Code's hook output limit. Run \`rulecast run ${session}--format agent\` for the full list.`;
+}
+function withinLimit(text2, delivery, event) {
+  if (text2.length <= CONTEXT_LIMIT) return text2;
+  const notice = cutNotice(delivery, event);
+  const room = CONTEXT_LIMIT - notice.length;
+  const cut = text2.slice(0, room);
+  const lastLine = cut.lastIndexOf("\n");
+  return (lastLine > room / 2 ? cut.slice(0, lastLine) : cut.trimEnd()) + notice;
+}
+var NONE = { stdout: "", exitCode: 0 };
+var json2 = (value) => ({ stdout: JSON.stringify(value), exitCode: 0 });
+var claudeCodeAdapter = {
+  name: "claude-code",
+  label: "Claude Code",
+  maxContextChars: CONTEXT_BUDGET,
+  /** Recorded from 2.1.278: /compact re-attaches the 5 most recently read, edited or written files. */
+  restoredFiles: 5,
+  parse: parseClaudeCode,
+  format(delivery, event, options) {
+    const text2 = renderAgentText(delivery, options);
+    if (text2 === "") return NONE;
+    switch (event.kind) {
+      case "guard":
+        return json2({
+          hookSpecificOutput: {
+            hookEventName: "PreToolUse",
+            permissionDecision: "deny",
+            permissionDecisionReason: withinLimit(`${DENY_PREAMBLE}
+
+${text2}`, delivery, event)
+          }
+        });
+      case "touch":
+      case "edit":
+        return json2({
+          hookSpecificOutput: { hookEventName: "PostToolUse", additionalContext: withinLimit(text2, delivery, event) }
+        });
+      case "reset":
+        return json2({
+          hookSpecificOutput: { hookEventName: "SessionStart", additionalContext: withinLimit(text2, delivery, event) }
+        });
+      case "verify":
+        if (delivery.stop === "block")
+          return json2({ decision: "block", reason: withinLimit(`${BLOCK_PREAMBLE}
+
+${text2}`, delivery, event) });
+        if (delivery.stop === "capReached")
+          return json2({ systemMessage: withinLimit(`${CAP_PREAMBLE}
+
+${text2}`, delivery, event) });
+        return NONE;
+      default:
+        return NONE;
+    }
+  },
+  install: {
+    markers: [".claude/", "CLAUDE.md"],
+    scopes: [
+      { scope: "shared", file: ".claude/settings.json" },
+      { scope: "personal", file: ".claude/settings.local.json" }
+    ],
+    command: (local) => local ? '"$CLAUDE_PROJECT_DIR"/node_modules/.bin/rulecast hook claude-code' : "rulecast hook claude-code",
+    merge: mergeHooks,
+    remove: removeHooks
+  }
+};
+
+// src/adapters/index.ts
+var ADAPTERS = [claudeCodeAdapter];
+function adapterByName(name) {
+  return ADAPTERS.find((adapter) => adapter.name === name);
+}
+
+export {
+  createRegistry,
+  builtinDetectors,
+  claudeCodeAdapter,
+  ADAPTERS,
+  adapterByName
+};