@lucasacoutinho/archer 0.2.1 → 0.3.0

package/dist/index.cjs

@@ -1,2484 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  ArchExpectation: () => ArchExpectation,
-  ArchitectureError: () => ArchitectureError,
-  ArchitectureLayers: () => ArchitectureLayers,
-  ArchitectureSuite: () => ArchitectureSuite,
-  LayerExpectation: () => LayerExpectation,
-  analyze: () => analyze,
-  applyBaseline: () => applyBaseline,
-  applyPreset: () => applyPreset,
-  archerMatchers: () => archerMatchers,
-  availablePresets: () => availablePresets,
-  clearAnalysisCache: () => clearAnalysisCache,
-  createArcher: () => createArcher,
-  createBaseline: () => createBaseline,
-  defineConfig: () => defineConfig,
-  formatResult: () => formatResult,
-  readBaseline: () => readBaseline,
-  registerPreset: () => registerPreset,
-  report: () => report,
-  violationFingerprint: () => violationFingerprint,
-  writeBaseline: () => writeBaseline
-});
-module.exports = __toCommonJS(src_exports);
-
-// src/analysis/analyzer.ts
-var import_promises2 = require("fs/promises");
-var import_node_path3 = __toESM(require("path"), 1);
-var import_tinyglobby2 = require("tinyglobby");
-
-// src/analysis/projects.ts
-var import_node_fs = require("fs");
-var import_node_module = require("module");
-var import_node_path = __toESM(require("path"), 1);
-var import_tinyglobby = require("tinyglobby");
-var import_typescript = __toESM(require("typescript"), 1);
-function normalize(value) {
-  return value.replaceAll("\\", "/");
-}
-function canonical(value) {
-  return process.platform === "win32" ? value.toLowerCase() : value;
-}
-function defaultCompilerOptions() {
-  return {
-    allowJs: true,
-    module: import_typescript.default.ModuleKind.NodeNext,
-    moduleResolution: import_typescript.default.ModuleResolutionKind.NodeNext
-  };
-}
-function configPathFrom(value, root) {
-  const resolved = import_node_path.default.resolve(root, value);
-  if (import_node_path.default.extname(resolved).toLowerCase() === ".json") {
-    return resolved;
-  }
-  return import_node_path.default.join(resolved, "tsconfig.json");
-}
-function parseProject(configPath) {
-  const readResult = import_typescript.default.readConfigFile(configPath, import_typescript.default.sys.readFile);
-  if (readResult.error !== void 0) {
-    throw new Error(import_typescript.default.flattenDiagnosticMessageText(readResult.error.messageText, "\n"));
-  }
-  const root = import_node_path.default.dirname(configPath);
-  const parsed = import_typescript.default.parseJsonConfigFileContent(
-    readResult.config,
-    import_typescript.default.sys,
-    root,
-    void 0,
-    configPath
-  );
-  if (parsed.errors.length > 0) {
-    const errors = parsed.errors.map(
-      (error) => import_typescript.default.flattenDiagnosticMessageText(error.messageText, "\n")
-    );
-    throw new Error(`Could not read ${configPath}:
-${errors.join("\n")}`);
-  }
-  const compilerOptions = { ...parsed.options, allowJs: true };
-  const program = import_typescript.default.createProgram({
-    options: compilerOptions,
-    ...parsed.projectReferences === void 0 ? {} : { projectReferences: parsed.projectReferences },
-    rootNames: parsed.fileNames
-  });
-  return {
-    compilerOptions,
-    configPath,
-    files: new Set(parsed.fileNames.map((file) => canonical(import_node_path.default.resolve(file)))),
-    info: {
-      name: normalize(import_node_path.default.basename(root)),
-      root: normalize(root),
-      tsconfig: normalize(configPath)
-    },
-    moduleResolutionCache: import_typescript.default.createModuleResolutionCache(root, canonical, compilerOptions),
-    program,
-    root
-  };
-}
-function fallbackProject(root) {
-  const compilerOptions = defaultCompilerOptions();
-  const configPath = import_node_path.default.join(root, "tsconfig.json");
-  return {
-    compilerOptions,
-    configPath,
-    files: /* @__PURE__ */ new Set(),
-    info: { name: import_node_path.default.basename(root), root: normalize(root), tsconfig: normalize(configPath) },
-    moduleResolutionCache: import_typescript.default.createModuleResolutionCache(root, canonical, compilerOptions),
-    program: import_typescript.default.createProgram({ options: compilerOptions, rootNames: [] }),
-    root
-  };
-}
-function referencedConfigs(project) {
-  return (project.program.getResolvedProjectReferences() ?? []).flatMap((reference) => {
-    if (reference === void 0) {
-      return [];
-    }
-    return [reference.sourceFile.fileName];
-  });
-}
-function readWorkspacePatterns(root) {
-  const packagePath = import_node_path.default.join(root, "package.json");
-  const patterns = [];
-  if ((0, import_node_fs.existsSync)(packagePath)) {
-    const packageJson = JSON.parse((0, import_node_fs.readFileSync)(packagePath, "utf8"));
-    if (Array.isArray(packageJson.workspaces)) {
-      patterns.push(...packageJson.workspaces);
-    } else {
-      patterns.push(
-        ...packageJson.workspaces?.packages ?? []
-      );
-    }
-  }
-  const pnpmWorkspace = import_node_path.default.join(root, "pnpm-workspace.yaml");
-  if ((0, import_node_fs.existsSync)(pnpmWorkspace)) {
-    const yaml = (0, import_node_fs.readFileSync)(pnpmWorkspace, "utf8");
-    const packageBlock = yaml.match(/^packages:\s*\n((?:^[ \t]+-.*\n?)*)/mu)?.[1] ?? "";
-    for (const match of packageBlock.matchAll(/^[ \t]+-[ \t]+["']?([^"'\n]+?)["']?[ \t]*$/gmu)) {
-      const pattern = match[1]?.trim();
-      if (pattern !== void 0) patterns.push(pattern);
-    }
-  }
-  return [...new Set(patterns)];
-}
-async function workspaceConfigPaths(root) {
-  const patterns = readWorkspacePatterns(root);
-  if (patterns.length === 0) {
-    return [];
-  }
-  return (0, import_tinyglobby.glob)(
-    patterns.map((pattern) => `${pattern}/tsconfig.json`),
-    {
-      absolute: true,
-      cwd: root,
-      onlyFiles: true
-    }
-  );
-}
-async function discoverProjects(root, options) {
-  if (options.tsconfig === false && options.projects === void 0) {
-    return [fallbackProject(root)];
-  }
-  const requested = options.projects?.map(
-    (project) => typeof project === "string" ? { tsconfig: project } : project
-  ) ?? [];
-  const primaryPath = configPathFrom(
-    options.tsconfig === false ? "tsconfig.json" : options.tsconfig ?? "tsconfig.json",
-    root
-  );
-  const initialPaths = /* @__PURE__ */ new Set();
-  if ((0, import_node_fs.existsSync)(primaryPath)) {
-    initialPaths.add(primaryPath);
-  }
-  const requestedMatches = await Promise.all(
-    requested.map(async (project) => ({
-      matches: await (0, import_tinyglobby.glob)(project.tsconfig, { absolute: true, cwd: root, onlyFiles: true }),
-      project
-    }))
-  );
-  for (const { matches, project } of requestedMatches) {
-    if (matches.length === 0) {
-      initialPaths.add(configPathFrom(project.tsconfig, root));
-    } else {
-      matches.forEach((match) => initialPaths.add(import_node_path.default.resolve(match)));
-    }
-  }
-  if (options.workspaces !== false) {
-    for (const configPath of await workspaceConfigPaths(root)) {
-      initialPaths.add(import_node_path.default.resolve(configPath));
-    }
-  }
-  if (initialPaths.size === 0) {
-    return [fallbackProject(root)];
-  }
-  const projects = /* @__PURE__ */ new Map();
-  const queue = [...initialPaths];
-  while (queue.length > 0) {
-    const configPath = import_node_path.default.resolve(queue.shift() ?? "");
-    if (projects.has(canonical(configPath)) || !(0, import_node_fs.existsSync)(configPath)) {
-      continue;
-    }
-    const project = parseProject(configPath);
-    projects.set(canonical(configPath), project);
-    for (const reference of referencedConfigs(project)) {
-      queue.push(reference);
-    }
-  }
-  return [...projects.values()].toSorted((left, right) => right.root.length - left.root.length);
-}
-function projectForFile(fileName, projects) {
-  const resolved = canonical(import_node_path.default.resolve(fileName));
-  return projects.find((project) => project.files.has(resolved)) ?? projects.find((project) => {
-    const relative = import_node_path.default.relative(project.root, fileName);
-    return relative !== ".." && !relative.startsWith(`..${import_node_path.default.sep}`) && !import_node_path.default.isAbsolute(relative);
-  }) ?? projects[0] ?? fallbackProject(import_node_path.default.dirname(fileName));
-}
-async function discoverWorkspacePackages(root) {
-  const patterns = readWorkspacePatterns(root);
-  const packagePaths = patterns.length === 0 ? [] : await (0, import_tinyglobby.glob)(
-    patterns.map((pattern) => `${pattern}/package.json`),
-    {
-      absolute: true,
-      cwd: root,
-      onlyFiles: true
-    }
-  );
-  return packagePaths.flatMap((packagePath) => {
-    const packageJson = JSON.parse((0, import_node_fs.readFileSync)(packagePath, "utf8"));
-    return packageJson.name === void 0 ? [] : [{ name: packageJson.name, root: import_node_path.default.dirname(packagePath) }];
-  });
-}
-function packageNameOf(specifier) {
-  if (specifier.startsWith("@")) {
-    return specifier.split("/").slice(0, 2).join("/");
-  }
-  return specifier.split("/")[0] ?? specifier;
-}
-function within(root, fileName) {
-  const relative = import_node_path.default.relative(root, fileName);
-  return relative !== ".." && !relative.startsWith(`..${import_node_path.default.sep}`) && !import_node_path.default.isAbsolute(relative);
-}
-function realPath(fileName, followSymlinks) {
-  if (!followSymlinks) {
-    return import_node_path.default.resolve(fileName);
-  }
-  try {
-    return import_node_fs.realpathSync.native(fileName);
-  } catch {
-    return import_node_path.default.resolve(fileName);
-  }
-}
-async function createDependencyResolver(root, options) {
-  const workspaces = await discoverWorkspacePackages(root);
-  const followSymlinks = options.followSymlinks !== false;
-  const builtins = new Set(
-    import_node_module.builtinModules.map((name) => name.startsWith("node:") ? name.slice(5) : name)
-  );
-  return (reference, from, sourceFile, project) => {
-    if (reference.target !== void 0) {
-      return {
-        external: true,
-        resolution: "dynamic",
-        resolved: false,
-        target: reference.target
-      };
-    }
-    const specifier = reference.specifier;
-    if (specifier.startsWith("bun:")) {
-      return { external: true, resolution: "bun", resolved: true, target: specifier };
-    }
-    const withoutNode = specifier.startsWith("node:") ? specifier.slice(5) : specifier;
-    const builtinRoot = withoutNode.split("/")[0];
-    if (specifier.startsWith("node:") || builtinRoot !== void 0 && builtins.has(builtinRoot)) {
-      return {
-        external: true,
-        resolution: "node",
-        resolved: true,
-        target: specifier.startsWith("node:") ? specifier : `node:${specifier}`
-      };
-    }
-    const mode = import_typescript.default.getModeForUsageLocation(sourceFile, reference.node, project.compilerOptions);
-    const resolved = import_typescript.default.resolveModuleName(
-      specifier,
-      from,
-      project.compilerOptions,
-      import_typescript.default.sys,
-      project.moduleResolutionCache,
-      void 0,
-      mode
-    ).resolvedModule;
-    if (resolved === void 0) {
-      return {
-        external: specifier.startsWith(".") === false && import_node_path.default.isAbsolute(specifier) === false,
-        resolution: "unresolved",
-        resolved: false,
-        target: `unresolved:${specifier}`
-      };
-    }
-    const resolvedPath = realPath(resolved.resolvedFileName, followSymlinks);
-    const workspace = workspaces.find((candidate) => within(candidate.root, resolvedPath));
-    if (workspace !== void 0) {
-      return {
-        external: false,
-        packageName: workspace.name,
-        resolution: "local",
-        resolved: true,
-        target: normalize(import_node_path.default.relative(root, resolvedPath))
-      };
-    }
-    const rootRelative = normalize(import_node_path.default.relative(root, resolvedPath));
-    if (within(root, resolvedPath) && !rootRelative.split("/").includes("node_modules")) {
-      return {
-        external: false,
-        resolution: "local",
-        resolved: true,
-        target: rootRelative
-      };
-    }
-    if (specifier.startsWith(".") || import_node_path.default.isAbsolute(specifier)) {
-      return {
-        external: true,
-        resolution: "file",
-        resolved: true,
-        target: `file:${normalize(import_node_path.default.relative(root, resolvedPath))}`
-      };
-    }
-    const packageName = packageNameOf(specifier);
-    return {
-      external: true,
-      packageName,
-      resolution: "npm",
-      resolved: true,
-      target: `npm:${specifier}`
-    };
-  };
-}
-
-// src/analysis/source.ts
-var import_promises = require("fs/promises");
-var import_node_path2 = __toESM(require("path"), 1);
-var import_typescript2 = __toESM(require("typescript"), 1);
-function isStringLiteralLike(node) {
-  return node !== void 0 && (import_typescript2.default.isStringLiteral(node) || import_typescript2.default.isNoSubstitutionTemplateLiteral(node));
-}
-function importsOnlyTypes(node) {
-  const clause = node.importClause;
-  if (clause === void 0) {
-    return false;
-  }
-  if (clause.isTypeOnly) {
-    return true;
-  }
-  if (clause.name !== void 0 || clause.namedBindings === void 0) {
-    return false;
-  }
-  if (import_typescript2.default.isNamespaceImport(clause.namedBindings)) {
-    return false;
-  }
-  return clause.namedBindings.elements.length > 0 && clause.namedBindings.elements.every((element) => element.isTypeOnly);
-}
-function exportOnlyTypes(node) {
-  if (node.isTypeOnly) return true;
-  return node.exportClause !== void 0 && import_typescript2.default.isNamedExports(node.exportClause) && node.exportClause.elements.length > 0 && node.exportClause.elements.every((element) => element.isTypeOnly);
-}
-function collectImports(sourceFile, checker) {
-  const imports = [];
-  for (const statement of sourceFile.statements) {
-    if (import_typescript2.default.isImportDeclaration(statement) && isStringLiteralLike(statement.moduleSpecifier)) {
-      imports.push({
-        kind: importsOnlyTypes(statement) ? "type" : "static",
-        node: statement.moduleSpecifier,
-        specifier: statement.moduleSpecifier.text
-      });
-      continue;
-    }
-    if (import_typescript2.default.isExportDeclaration(statement) && isStringLiteralLike(statement.moduleSpecifier)) {
-      imports.push({
-        kind: exportOnlyTypes(statement) ? "type" : "static",
-        node: statement.moduleSpecifier,
-        specifier: statement.moduleSpecifier.text
-      });
-      continue;
-    }
-    if (import_typescript2.default.isImportEqualsDeclaration(statement) && import_typescript2.default.isExternalModuleReference(statement.moduleReference) && isStringLiteralLike(statement.moduleReference.expression)) {
-      imports.push({
-        kind: statement.isTypeOnly ? "type" : "require",
-        node: statement.moduleReference.expression,
-        specifier: statement.moduleReference.expression.text
-      });
-    }
-  }
-  function visit(node) {
-    if (import_typescript2.default.isCallExpression(node) && node.arguments.length === 1) {
-      const argument = node.arguments[0];
-      if (node.expression.kind === import_typescript2.default.SyntaxKind.ImportKeyword && argument !== void 0) {
-        if (isStringLiteralLike(argument)) {
-          imports.push({ kind: "dynamic", node: argument, specifier: argument.text });
-        } else {
-          const synthetic = import_typescript2.default.factory.createStringLiteral(argument.getText(sourceFile));
-          import_typescript2.default.setTextRange(synthetic, argument);
-          imports.push({
-            kind: "dynamic",
-            node: synthetic,
-            specifier: argument.getText(sourceFile),
-            target: "dynamic:unknown"
-          });
-        }
-      } else if (import_typescript2.default.isIdentifier(node.expression) && node.expression.text === "require") {
-        const symbol = checker?.getSymbolAtLocation(node.expression);
-        const isGlobal = checker === void 0 || (symbol?.declarations?.some(
-          (declaration) => declaration.getSourceFile() !== sourceFile
-        ) ?? symbol === void 0);
-        if (isGlobal && isStringLiteralLike(argument)) {
-          imports.push({ kind: "require", node: argument, specifier: argument.text });
-        } else if (isGlobal && argument !== void 0) {
-          const synthetic = import_typescript2.default.factory.createStringLiteral(argument.getText(sourceFile));
-          import_typescript2.default.setTextRange(synthetic, argument);
-          imports.push({
-            kind: "require",
-            node: synthetic,
-            specifier: argument.getText(sourceFile),
-            target: "dynamic:unknown"
-          });
-        }
-      }
-    } else if (import_typescript2.default.isImportTypeNode(node) && import_typescript2.default.isLiteralTypeNode(node.argument) && isStringLiteralLike(node.argument.literal)) {
-      imports.push({
-        kind: "type",
-        node: node.argument.literal,
-        specifier: node.argument.literal.text
-      });
-    }
-    import_typescript2.default.forEachChild(node, visit);
-  }
-  import_typescript2.default.forEachChild(sourceFile, visit);
-  return imports;
-}
-function hasModifier(node, kind) {
-  return import_typescript2.default.canHaveModifiers(node) && (import_typescript2.default.getModifiers(node)?.some((modifier) => modifier.kind === kind) ?? false);
-}
-function decoratorNames(node) {
-  if (!import_typescript2.default.canHaveDecorators(node)) {
-    return [];
-  }
-  return (import_typescript2.default.getDecorators(node) ?? []).map((decorator) => decorator.expression.getText());
-}
-function visibility(node) {
-  if (hasModifier(node, import_typescript2.default.SyntaxKind.PrivateKeyword)) {
-    return "private";
-  }
-  if (hasModifier(node, import_typescript2.default.SyntaxKind.ProtectedKeyword)) {
-    return "protected";
-  }
-  return "public";
-}
-function methodsOf(node) {
-  return node.members.flatMap((member) => {
-    if (!import_typescript2.default.isMethodDeclaration(member) && !import_typescript2.default.isMethodSignature(member)) {
-      return [];
-    }
-    return [
-      {
-        name: member.name.getText(),
-        static: hasModifier(member, import_typescript2.default.SyntaxKind.StaticKeyword),
-        visibility: visibility(member)
-      }
-    ];
-  });
-}
-function declarationBase(node, sourceFile) {
-  const position = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
-  return {
-    abstract: hasModifier(node, import_typescript2.default.SyntaxKind.AbstractKeyword),
-    column: position.character + 1,
-    decorators: decoratorNames(node),
-    defaultExport: hasModifier(node, import_typescript2.default.SyntaxKind.DefaultKeyword),
-    exported: hasModifier(node, import_typescript2.default.SyntaxKind.ExportKeyword),
-    line: position.line + 1
-  };
-}
-function heritage(node, token, checker) {
-  const types = node.heritageClauses?.filter((clause) => clause.token === token).flatMap((clause) => clause.types) ?? [];
-  return [
-    ...new Set(
-      types.flatMap((type) => {
-        const text = type.expression.getText();
-        const symbol = checker?.getSymbolAtLocation(type.expression);
-        const resolvedSymbol = symbol !== void 0 && (symbol.flags & import_typescript2.default.SymbolFlags.Alias) !== 0 ? checker?.getAliasedSymbol(symbol) : symbol;
-        const resolved = resolvedSymbol?.getName();
-        return resolved === void 0 || resolved === "unknown" || resolved === text ? [text] : [text, resolved];
-      })
-    )
-  ];
-}
-function collectDeclarations(sourceFile, checker) {
-  return sourceFile.statements.flatMap((statement) => {
-    if (import_typescript2.default.isClassDeclaration(statement) || import_typescript2.default.isInterfaceDeclaration(statement)) {
-      const name = statement.name?.text ?? "default";
-      return [
-        {
-          ...declarationBase(statement, sourceFile),
-          extends: heritage(statement, import_typescript2.default.SyntaxKind.ExtendsKeyword, checker),
-          implements: import_typescript2.default.isClassDeclaration(statement) ? heritage(statement, import_typescript2.default.SyntaxKind.ImplementsKeyword, checker) : [],
-          kind: import_typescript2.default.isClassDeclaration(statement) ? "class" : "interface",
-          methods: methodsOf(statement),
-          name,
-          readonlyProperties: statement.members.filter((member) => import_typescript2.default.isPropertyDeclaration(member) || import_typescript2.default.isPropertySignature(member)).every((member) => hasModifier(member, import_typescript2.default.SyntaxKind.ReadonlyKeyword))
-        }
-      ];
-    }
-    if (import_typescript2.default.isEnumDeclaration(statement)) {
-      return [
-        {
-          ...declarationBase(statement, sourceFile),
-          extends: [],
-          implements: [],
-          kind: "enum",
-          methods: [],
-          name: statement.name.text,
-          readonlyProperties: true
-        }
-      ];
-    }
-    if (import_typescript2.default.isFunctionDeclaration(statement)) {
-      return [
-        {
-          ...declarationBase(statement, sourceFile),
-          extends: [],
-          implements: [],
-          kind: "function",
-          methods: [],
-          name: statement.name?.text ?? "default",
-          readonlyProperties: true
-        }
-      ];
-    }
-    if (import_typescript2.default.isTypeAliasDeclaration(statement)) {
-      return [
-        {
-          ...declarationBase(statement, sourceFile),
-          extends: [],
-          implements: [],
-          kind: "type",
-          methods: [],
-          name: statement.name.text,
-          readonlyProperties: true
-        }
-      ];
-    }
-    if (import_typescript2.default.isVariableStatement(statement)) {
-      const base = declarationBase(statement, sourceFile);
-      return statement.declarationList.declarations.map((declaration) => ({
-        ...base,
-        extends: [],
-        implements: [],
-        kind: "variable",
-        methods: [],
-        name: declaration.name.getText(),
-        readonlyProperties: true
-      }));
-    }
-    return [];
-  });
-}
-function collectImportedBindings(sourceFile) {
-  const bindings = /* @__PURE__ */ new Map();
-  function add(localName, importedFrom, importedName, namespace) {
-    bindings.set(localName, { importedFrom, importedName, namespace });
-  }
-  for (const statement of sourceFile.statements) {
-    if (import_typescript2.default.isImportDeclaration(statement) && isStringLiteralLike(statement.moduleSpecifier)) {
-      const importedFrom = statement.moduleSpecifier.text;
-      const clause = statement.importClause;
-      if (clause?.name !== void 0) add(clause.name.text, importedFrom, "default", true);
-      if (clause?.namedBindings !== void 0) {
-        if (import_typescript2.default.isNamespaceImport(clause.namedBindings)) {
-          add(clause.namedBindings.name.text, importedFrom, "*", true);
-        } else {
-          for (const element of clause.namedBindings.elements) {
-            add(
-              element.name.text,
-              importedFrom,
-              element.propertyName?.text ?? element.name.text,
-              false
-            );
-          }
-        }
-      }
-      continue;
-    }
-    if (import_typescript2.default.isImportEqualsDeclaration(statement) && import_typescript2.default.isExternalModuleReference(statement.moduleReference) && isStringLiteralLike(statement.moduleReference.expression)) {
-      add(statement.name.text, statement.moduleReference.expression.text, "*", true);
-      continue;
-    }
-    if (!import_typescript2.default.isVariableStatement(statement)) continue;
-    for (const declaration of statement.declarationList.declarations) {
-      const initializer = declaration.initializer;
-      if (initializer === void 0 || !import_typescript2.default.isCallExpression(initializer) || !import_typescript2.default.isIdentifier(initializer.expression) || initializer.expression.text !== "require" || !isStringLiteralLike(initializer.arguments[0])) {
-        continue;
-      }
-      const importedFrom = initializer.arguments[0].text;
-      if (import_typescript2.default.isIdentifier(declaration.name)) {
-        add(declaration.name.text, importedFrom, "*", true);
-      } else if (import_typescript2.default.isObjectBindingPattern(declaration.name)) {
-        for (const element of declaration.name.elements) {
-          if (!import_typescript2.default.isIdentifier(element.name)) continue;
-          const importedName = element.propertyName?.getText(sourceFile) ?? element.name.text;
-          add(element.name.text, importedFrom, importedName, false);
-        }
-      }
-    }
-  }
-  return bindings;
-}
-function importedCall(expression, bindings) {
-  if (import_typescript2.default.isIdentifier(expression)) return bindings.get(expression.text);
-  if (import_typescript2.default.isPropertyAccessExpression(expression) && import_typescript2.default.isIdentifier(expression.expression)) {
-    const namespace = bindings.get(expression.expression.text);
-    if (namespace?.namespace === true) {
-      return { ...namespace, importedName: expression.name.text, namespace: false };
-    }
-  }
-  if (import_typescript2.default.isElementAccessExpression(expression) && import_typescript2.default.isIdentifier(expression.expression) && isStringLiteralLike(expression.argumentExpression)) {
-    const namespace = bindings.get(expression.expression.text);
-    if (namespace?.namespace === true) {
-      return {
-        ...namespace,
-        importedName: expression.argumentExpression.text,
-        namespace: false
-      };
-    }
-  }
-  return void 0;
-}
-function collectUses(sourceFile, checker) {
-  const uses = [];
-  const importedBindings = collectImportedBindings(sourceFile);
-  function add(node, kind, name, imported) {
-    const position = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
-    uses.push({
-      column: position.character + 1,
-      ...imported === void 0 ? {} : { importedFrom: imported.importedFrom, importedName: imported.importedName },
-      kind,
-      line: position.line + 1,
-      name
-    });
-  }
-  function visit(node) {
-    if (import_typescript2.default.isCallExpression(node)) {
-      const imported = importedCall(node.expression, importedBindings);
-      if (imported !== void 0) {
-        add(node.expression, "call", node.expression.getText(sourceFile), imported);
-      } else if (import_typescript2.default.isIdentifier(node.expression)) {
-        const symbol = checker?.getSymbolAtLocation(node.expression);
-        const isGlobal = checker === void 0 || (symbol?.declarations?.some(
-          (declaration) => declaration.getSourceFile() !== sourceFile
-        ) ?? false);
-        if (isGlobal) add(node.expression, "call", node.expression.text);
-      }
-    }
-    if (import_typescript2.default.isBinaryExpression(node) && (node.operatorToken.kind === import_typescript2.default.SyntaxKind.EqualsEqualsToken || node.operatorToken.kind === import_typescript2.default.SyntaxKind.ExclamationEqualsToken)) {
-      add(node.operatorToken, "loose-equality", node.operatorToken.getText(sourceFile));
-    }
-    import_typescript2.default.forEachChild(node, visit);
-  }
-  import_typescript2.default.forEachChild(sourceFile, visit);
-  return uses;
-}
-function collectExports(sourceFile, checker) {
-  const moduleSymbol = checker?.getSymbolAtLocation(sourceFile);
-  if (moduleSymbol !== void 0) {
-    return checker?.getExportsOfModule(moduleSymbol).map((symbol) => symbol.getName()).toSorted() ?? [];
-  }
-  return collectDeclarations(sourceFile).filter((declaration) => declaration.exported || declaration.defaultExport).map((declaration) => declaration.defaultExport ? "default" : declaration.name);
-}
-function scriptKind(fileName) {
-  switch (import_node_path2.default.extname(fileName).toLowerCase()) {
-    case ".js":
-    case ".cjs":
-    case ".mjs":
-      return import_typescript2.default.ScriptKind.JS;
-    case ".jsx":
-      return import_typescript2.default.ScriptKind.JSX;
-    case ".json":
-      return import_typescript2.default.ScriptKind.JSON;
-    case ".tsx":
-      return import_typescript2.default.ScriptKind.TSX;
-    default:
-      return import_typescript2.default.ScriptKind.TS;
-  }
-}
-async function analyzeSource(absolutePath, root, context) {
-  const source = await (0, import_promises.readFile)(absolutePath, "utf8");
-  const sourceFile = context.sourceFile ?? import_typescript2.default.createSourceFile(
-    absolutePath,
-    source,
-    import_typescript2.default.ScriptTarget.Latest,
-    true,
-    scriptKind(absolutePath)
-  );
-  const modulePath = import_node_path2.default.relative(root, absolutePath).replaceAll("\\", "/");
-  const dependencies = [];
-  for (const reference of collectImports(sourceFile, context.checker)) {
-    const position = sourceFile.getLineAndCharacterOfPosition(reference.node.getStart(sourceFile));
-    dependencies.push({
-      ...context.resolve(reference, sourceFile),
-      column: position.character + 1,
-      from: modulePath,
-      kind: reference.kind,
-      line: position.line + 1,
-      specifier: reference.specifier
-    });
-  }
-  const sourceLines = source.length === 0 ? [] : source.split(/\r?\n/u);
-  return {
-    absolutePath,
-    declarations: collectDeclarations(sourceFile, context.checker),
-    dependencies,
-    exports: collectExports(sourceFile, context.checker),
-    lines: sourceLines.length,
-    path: modulePath,
-    ...context.project === void 0 ? {} : { project: context.project },
-    sourceLines,
-    uses: collectUses(sourceFile, context.checker)
-  };
-}
-
-// src/analysis/analyzer.ts
-var DEFAULT_INCLUDE = [
-  "src/**/*.{js,jsx,mjs,cjs,ts,tsx,mts,cts}",
-  "apps/*/src/**/*.{js,jsx,mjs,cjs,ts,tsx,mts,cts}",
-  "packages/*/src/**/*.{js,jsx,mjs,cjs,ts,tsx,mts,cts}"
-];
-var DEFAULT_EXCLUDE = [
-  "**/node_modules/**",
-  "**/dist/**",
-  "**/build/**",
-  "**/coverage/**"
-];
-var graphCache = /* @__PURE__ */ new Map();
-function stableOptions(options, root) {
-  return JSON.stringify({
-    cache: options.cache,
-    exclude: options.exclude,
-    followSymlinks: options.followSymlinks,
-    include: options.include,
-    includeTypeDeclarations: options.includeTypeDeclarations,
-    projects: options.projects,
-    root,
-    tsconfig: options.tsconfig,
-    workspaces: options.workspaces
-  });
-}
-async function cacheKey(files, options, root) {
-  const configurationFiles = await (0, import_tinyglobby2.glob)(
-    ["**/tsconfig*.json", "**/package.json", "pnpm-workspace.yaml"],
-    {
-      absolute: true,
-      cwd: root,
-      ignore: DEFAULT_EXCLUDE,
-      onlyFiles: true
-    }
-  );
-  const signatures = await Promise.all(
-    [.../* @__PURE__ */ new Set([...files, ...configurationFiles])].toSorted().map(async (file) => {
-      const details = await (0, import_promises2.stat)(file);
-      return `${file}:${details.size}:${details.mtimeMs}`;
-    })
-  );
-  return `${stableOptions(options, root)}
-${signatures.join("\n")}`;
-}
-async function discoverFiles(root, options) {
-  const ignore = [
-    ...DEFAULT_EXCLUDE,
-    ...options.includeTypeDeclarations === true ? [] : ["**/*.d.ts"],
-    ...options.exclude ?? []
-  ];
-  const overrides = (options.projects ?? []).flatMap(
-    (project) => typeof project === "string" || project.include === void 0 ? [] : [project]
-  );
-  const overridePatterns = [];
-  const overrideRoots = [];
-  const resolvedOverrides = await Promise.all(
-    overrides.map(async (project) => {
-      const configPaths = await (0, import_tinyglobby2.glob)(project.tsconfig, {
-        absolute: true,
-        cwd: root,
-        onlyFiles: true
-      });
-      return {
-        includes: project.include ?? [],
-        paths: configPaths.length > 0 ? configPaths : [import_node_path3.default.resolve(root, project.tsconfig)]
-      };
-    })
-  );
-  for (const { includes, paths } of resolvedOverrides) {
-    for (const configPath of paths) {
-      const projectRoot = import_node_path3.default.dirname(configPath);
-      const relativeRoot = import_node_path3.default.relative(root, projectRoot).replaceAll("\\", "/");
-      overrideRoots.push(relativeRoot === "" ? "**" : `${relativeRoot}/**`);
-      overridePatterns.push(
-        ...includes.map(
-          (pattern) => relativeRoot === "" ? pattern : `${relativeRoot}/${pattern}`
-        )
-      );
-    }
-  }
-  const files = await (0, import_tinyglobby2.glob)(options.include ?? DEFAULT_INCLUDE, {
-    absolute: true,
-    cwd: root,
-    dot: true,
-    followSymbolicLinks: options.followSymlinks !== false,
-    ignore: [...ignore, ...overrideRoots],
-    onlyFiles: true
-  });
-  if (overridePatterns.length === 0) {
-    return files;
-  }
-  const projectFiles = await (0, import_tinyglobby2.glob)(overridePatterns, {
-    absolute: true,
-    cwd: root,
-    dot: true,
-    followSymbolicLinks: options.followSymlinks !== false,
-    ignore,
-    onlyFiles: true
-  });
-  return [.../* @__PURE__ */ new Set([...files, ...projectFiles])];
-}
-async function buildGraph(files, root, options) {
-  const projects = await discoverProjects(root, options);
-  const resolve = await createDependencyResolver(root, options);
-  const modules = await Promise.all(
-    files.toSorted().map((file) => {
-      const absolutePath = import_node_path3.default.resolve(file);
-      const project = projectForFile(absolutePath, projects);
-      const sourceFile = project.program.getSourceFile(absolutePath);
-      return analyzeSource(absolutePath, root, {
-        checker: project.program.getTypeChecker(),
-        project: project.info.name,
-        resolve: (reference, resolvedSourceFile) => resolve(reference, absolutePath, resolvedSourceFile, project),
-        ...sourceFile === void 0 ? {} : { sourceFile }
-      });
-    })
-  );
-  return {
-    dependencies: modules.flatMap((sourceModule) => sourceModule.dependencies),
-    modules,
-    projects: projects.map((project) => project.info),
-    root
-  };
-}
-function clearAnalysisCache() {
-  graphCache.clear();
-}
-async function analyze(options = {}) {
-  const root = import_node_path3.default.resolve(options.root ?? process.cwd());
-  const files = await discoverFiles(root, options);
-  if (options.cache === false) {
-    return buildGraph(files, root, options);
-  }
-  const key = await cacheKey(files, options, root);
-  const cached = graphCache.get(key);
-  if (cached !== void 0) {
-    return cached;
-  }
-  const graph = buildGraph(files, root, options);
-  if (graphCache.size >= 10) graphCache.clear();
-  graphCache.set(key, graph);
-  try {
-    return await graph;
-  } catch (error) {
-    graphCache.delete(key);
-    throw error;
-  }
-}
-
-// src/reporting/baseline.ts
-var import_node_crypto = require("crypto");
-var import_promises3 = require("fs/promises");
-var import_node_path4 = __toESM(require("path"), 1);
-function violationFingerprint(violation2) {
-  const stableDetail = violation2.dependency ?? violation2.sourceLine;
-  const identity = [
-    violation2.ruleId ?? violation2.rule,
-    violation2.file ?? "",
-    stableDetail ?? (violation2.ruleId === void 0 ? violation2.message : "")
-  ].join("\0");
-  return (0, import_node_crypto.createHash)("sha256").update(identity).digest("hex").slice(0, 20);
-}
-function createBaseline(result) {
-  return {
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    version: 1,
-    violations: result.violations.map((violation2) => ({
-      ...violation2.file === void 0 ? {} : { file: violation2.file },
-      fingerprint: violationFingerprint(violation2),
-      message: violation2.message,
-      rule: violation2.ruleId ?? violation2.rule
-    }))
-  };
-}
-async function readBaseline(fileName) {
-  const parsed = JSON.parse(await (0, import_promises3.readFile)(fileName, "utf8"));
-  if (typeof parsed !== "object" || parsed === null || !("version" in parsed) || parsed.version !== 1 || !("violations" in parsed) || !Array.isArray(parsed.violations) || parsed.violations.some(
-    (entry) => typeof entry !== "object" || entry === null || !("fingerprint" in entry) || typeof entry.fingerprint !== "string"
-  )) {
-    throw new TypeError(`Unsupported Archer baseline '${fileName}'.`);
-  }
-  return parsed;
-}
-async function writeBaseline(fileName, baseline) {
-  await (0, import_promises3.mkdir)(import_node_path4.default.dirname(fileName), { recursive: true });
-  await (0, import_promises3.writeFile)(fileName, `${JSON.stringify(baseline, void 0, 2)}
-`, "utf8");
-}
-function applyBaseline(result, baseline) {
-  const known = new Set(baseline.violations.map((entry) => entry.fingerprint));
-  const violations = result.violations.filter(
-    (violation2) => !known.has(violationFingerprint(violation2))
-  );
-  const errors = violations.filter((violation2) => violation2.severity === "error").length;
-  const warnings = violations.filter((violation2) => violation2.severity === "warning").length;
-  const infos = violations.filter((violation2) => violation2.severity === "info").length;
-  return {
-    ...result,
-    errors,
-    infos,
-    ok: errors === 0,
-    violations,
-    warnings
-  };
-}
-
-// src/config/index.ts
-function defineConfig(config) {
-  return config;
-}
-
-// src/core/matchers.ts
-var import_picomatch = __toESM(require("picomatch"), 1);
-var GLOB_CHARACTERS = /[*?{[(]/u;
-function normalize2(value) {
-  if (value.startsWith("./")) {
-    return value.slice(2).replaceAll("\\", "/");
-  }
-  return value.replaceAll("\\", "/");
-}
-function matchesOne(candidate, rawSelector) {
-  const selector = normalize2(rawSelector);
-  if (/^(?:dynamic|file|node|npm|unresolved):\*$/u.test(selector)) {
-    return candidate.startsWith(selector.slice(0, -1));
-  }
-  if (!GLOB_CHARACTERS.test(selector)) {
-    if (candidate === selector || candidate.startsWith(`${selector}/`)) {
-      return true;
-    }
-    if (selector.startsWith("npm:") && candidate.startsWith(`${selector}/`)) {
-      return true;
-    }
-    return false;
-  }
-  return (0, import_picomatch.default)(selector, { dot: true })(candidate);
-}
-function selectorValues(selector) {
-  return typeof selector === "string" ? [selector] : selector;
-}
-function matchesSelector(candidate, selector) {
-  return selectorValues(selector).some((value) => matchesOne(candidate, value));
-}
-function formatSelector(selector) {
-  return selectorValues(selector).map((value) => `'${value}'`).join(", ");
-}
-
-// src/core/layers.ts
-function violation(rule, message, source, line, column) {
-  return {
-    ...column === void 0 ? {} : { column },
-    ...source === void 0 ? {} : { file: source.path },
-    ...line === void 0 ? {} : { line },
-    message,
-    rule,
-    severity: "error"
-  };
-}
-var ArchitectureLayers = class {
-  #definitions;
-  #suite;
-  constructor(suite, definitions) {
-    if (Object.keys(definitions).length === 0) {
-      throw new TypeError("layers() needs at least one named layer.");
-    }
-    this.#suite = suite;
-    this.#definitions = definitions;
-  }
-  where(name) {
-    return new LayerExpectation(this.#suite, this.#definitions, name);
-  }
-  toBeFreeOfCycles() {
-    const definitions = this.#definitions;
-    this.#suite.rule("layers-free-of-cycles", ({ graph }) => {
-      const adjacency = new Map(Object.keys(definitions).map((name) => [name, /* @__PURE__ */ new Set()]));
-      for (const dependency of graph.dependencies.filter((item) => item.resolution === "local")) {
-        const from = Object.entries(definitions).find(
-          ([, selector]) => matchesSelector(dependency.from, selector)
-        )?.[0];
-        const target = Object.entries(definitions).find(
-          ([, selector]) => matchesSelector(dependency.target, selector)
-        )?.[0];
-        if (from !== void 0 && target !== void 0 && from !== target) {
-          adjacency.get(from)?.add(target);
-        }
-      }
-      const visiting = /* @__PURE__ */ new Set();
-      const visited = /* @__PURE__ */ new Set();
-      const stack = [];
-      const found = [];
-      function visit(name) {
-        visiting.add(name);
-        stack.push(name);
-        for (const target of adjacency.get(name) ?? []) {
-          if (visiting.has(target)) {
-            found.push([...stack.slice(stack.indexOf(target)), target]);
-          } else if (!visited.has(target)) {
-            visit(target);
-          }
-        }
-        stack.pop();
-        visiting.delete(name);
-        visited.add(name);
-      }
-      for (const name of adjacency.keys()) {
-        if (!visited.has(name)) visit(name);
-      }
-      return found.map(
-        (cycle) => violation("named layers must be free of cycles", `Layer cycle: ${cycle.join(" -> ")}.`)
-      );
-    });
-    return this;
-  }
-};
-var LayerExpectation = class {
-  #definitions;
-  #name;
-  #selector;
-  #suite;
-  constructor(suite, definitions, name) {
-    const selector = definitions[name];
-    if (selector === void 0) {
-      throw new TypeError(`Unknown architecture layer '${name}'.`);
-    }
-    this.#suite = suite;
-    this.#definitions = definitions;
-    this.#name = name;
-    this.#selector = selector;
-  }
-  mayDependOn(...names) {
-    this.#suite.expect(this.#selector).localDependencies().toOnlyDependOn([...this.selectors(names), ...this.selectors([this.#name])]);
-    return this;
-  }
-  mayOnlyDependOn(...names) {
-    return this.mayDependOn(...names);
-  }
-  mayNotDependOn(...names) {
-    this.#suite.expect(this.#selector).localDependencies().not.toDependOn(this.selectors(names));
-    return this;
-  }
-  mayOnlyBeUsedBy(...names) {
-    this.#suite.expect(this.#selector).localDependencies().toOnlyBeDependedOnBy([...this.selectors(names), ...this.selectors([this.#name])]);
-    return this;
-  }
-  exposeThrough(...barrels) {
-    if (barrels.length === 0) {
-      throw new TypeError("exposeThrough() needs at least one public API selector.");
-    }
-    const selector = this.#selector;
-    const layerName = this.#name;
-    this.#suite.expect(selector).toSatisfy(`layer-${layerName}-public-api`, ({ graph }) => {
-      return graph.dependencies.flatMap((dependency) => {
-        if (dependency.resolution !== "local" || matchesSelector(dependency.from, selector) || !matchesSelector(dependency.target, selector) || matchesSelector(dependency.target, barrels)) {
-          return [];
-        }
-        const source = graph.modules.find((item) => item.path === dependency.from);
-        return [
-          violation(
-            `layer '${layerName}' must be exposed through ${barrels.join(", ")}`,
-            `Imports internal module '${dependency.target}' instead of a public API.`,
-            source,
-            dependency.line,
-            dependency.column
-          )
-        ];
-      });
-    });
-    return this;
-  }
-  selectors(names) {
-    return names.flatMap((name) => {
-      const selector = this.#definitions[name];
-      if (selector === void 0) {
-        throw new TypeError(`Unknown architecture layer '${name}'.`);
-      }
-      return selectorValues(selector);
-    });
-  }
-};
-
-// src/analysis/evaluation/cycles.ts
-var import_node_path5 = __toESM(require("path"), 1);
-
-// src/analysis/evaluation/shared.ts
-function selectedModules(graph, selection) {
-  return graph.modules.filter(
-    (sourceModule) => matchesSelector(sourceModule.path, selection.selector) && !selection.ignored.some((ignored) => matchesSelector(sourceModule.path, ignored))
-  );
-}
-function describeRule(rule) {
-  const subject = formatSelector(rule.selection.selector);
-  switch (rule.kind) {
-    case "depend-on":
-      return `${subject} must${rule.negated ? " not" : ""} ${rule.transitive ? "transitively " : ""}depend on ${formatSelector(rule.target)}`;
-    case "only-depend-on":
-      return `${subject} must${rule.negated ? " not" : ""} only depend on ${formatSelector(rule.target)}`;
-    case "depended-on-by":
-      return `${subject} must${rule.negated ? " not" : ""} be depended on by ${formatSelector(rule.target)}`;
-    case "only-depended-on-by":
-      return `${subject} must${rule.negated ? " not" : ""} only be depended on by ${formatSelector(rule.target)}`;
-    case "free-of-cycles":
-      return rule.collapseToFolderDepth === void 0 ? `${subject} must be free of cycles` : `${subject} must be free of folder cycles`;
-    case "prefix":
-      return `${subject} must${rule.negated ? " not" : ""} have prefix '${rule.value}'`;
-    case "suffix":
-      return `${subject} must${rule.negated ? " not" : ""} have suffix '${rule.value}'`;
-    case "line-count-less-than":
-      return `${subject} must${rule.negated ? " not" : ""} have fewer than ${rule.value} lines`;
-    case "declaration-kind":
-      return `${subject} must${rule.negated ? " not" : ""} contain only ${rule.declarationKind} declarations`;
-    case "abstract":
-      return `${subject} must${rule.negated ? " not" : ""} contain abstract classes`;
-    case "exported":
-      return `${subject} must${rule.negated ? " not" : ""} contain exported declarations`;
-    case "extend":
-      return `${subject} must${rule.negated ? " not" : ""} extend '${rule.value}'`;
-    case "implement":
-      return `${subject} must${rule.negated ? " not" : ""} implement '${rule.value}'`;
-    case "decorator":
-      return `${subject} must${rule.negated ? " not" : ""} use decorator '${rule.value}'`;
-    case "only-export":
-      return `${subject} must${rule.negated ? " not" : ""} only export ${rule.names.join(", ")}`;
-    case "readonly-properties":
-      return `${subject} must${rule.negated ? " not" : ""} have readonly properties`;
-    case "strict-equality":
-      return `${subject} must use strict equality`;
-    case "use-globals":
-      return `${subject} must${rule.negated ? " not" : ""} use globals ${rule.globals.join(", ")}`;
-    case "use-imported-symbols":
-      return `${subject} must${rule.negated ? " not" : ""} call ${rule.symbols.join(", ")} from '${rule.importedFrom}'`;
-    case "have-methods":
-      return `${subject} must${rule.negated ? " not" : ""} have methods ${rule.names.join(", ")}`;
-    case "have-visible-methods":
-      return `${subject} must${rule.negated ? " not" : ""} have ${rule.visibility ?? "public"} methods ${rule.names.join(", ")}`;
-    case "only-public-methods":
-      return `${subject} must${rule.negated ? " not" : ""} only have public methods ${rule.names.join(", ")}`;
-    case "resolvable-dependencies":
-      return `${subject} must have resolvable dependencies`;
-    case "public-api":
-      return `${subject} must${rule.negated ? " not" : ""} be public API files`;
-    case "custom":
-      return rule.id ?? "custom architecture rule";
-  }
-}
-function sourceLine(sourceModule, line) {
-  if (sourceModule === void 0 || line === void 0) {
-    return void 0;
-  }
-  return sourceModule.sourceLines[line - 1];
-}
-function makeViolation(rule, message, sourceModule, dependency, location, importChain) {
-  const line = dependency?.line ?? location?.line;
-  const column = dependency?.column ?? location?.column;
-  const content = sourceLine(sourceModule, line);
-  return {
-    ...column === void 0 ? {} : { column },
-    ...dependency === void 0 ? {} : { dependency: dependency.target },
-    ...sourceModule === void 0 ? {} : { file: sourceModule.path },
-    ...importChain === void 0 ? {} : { importChain },
-    ...line === void 0 ? {} : { line },
-    message,
-    ...rule.reason === void 0 ? {} : { reason: rule.reason },
-    rule: describeRule(rule),
-    ...rule.id === void 0 ? {} : { ruleId: rule.id },
-    severity: rule.severity,
-    ...content === void 0 ? {} : { sourceLine: content }
-  };
-}
-function noMatchViolation(rule) {
-  return makeViolation(rule, `No files matched ${formatSelector(rule.selection.selector)}.`);
-}
-
-// src/analysis/evaluation/cycles.ts
-function collapsedPath(fileName, depth) {
-  if (depth === void 0) {
-    return fileName;
-  }
-  return fileName.split("/").slice(0, depth).join("/");
-}
-function adjacencyFor(modules, rule) {
-  const sourcePaths = new Set(modules.map((sourceModule) => sourceModule.path));
-  const adjacency = /* @__PURE__ */ new Map();
-  for (const sourceModule of modules) {
-    const from = collapsedPath(sourceModule.path, rule.collapseToFolderDepth);
-    const targets = adjacency.get(from) ?? /* @__PURE__ */ new Set();
-    for (const dependency of sourceModule.dependencies) {
-      if (sourcePaths.has(dependency.target) && (rule.dependencyKinds === void 0 || rule.dependencyKinds.includes(dependency.kind))) {
-        const target = collapsedPath(dependency.target, rule.collapseToFolderDepth);
-        if (target !== from || dependency.target === sourceModule.path) {
-          targets.add(target);
-        }
-      }
-    }
-    adjacency.set(from, targets);
-  }
-  return new Map([...adjacency].map(([key, values]) => [key, [...values]]));
-}
-function stronglyConnectedComponents(adjacency) {
-  const indexes = /* @__PURE__ */ new Map();
-  const lowLinks = /* @__PURE__ */ new Map();
-  const stack = [];
-  const onStack = /* @__PURE__ */ new Set();
-  const components = [];
-  let index = 0;
-  function connect(node) {
-    indexes.set(node, index);
-    lowLinks.set(node, index);
-    index += 1;
-    stack.push(node);
-    onStack.add(node);
-    for (const target of adjacency.get(node) ?? []) {
-      if (!indexes.has(target)) {
-        connect(target);
-        lowLinks.set(node, Math.min(lowLinks.get(node) ?? 0, lowLinks.get(target) ?? 0));
-      } else if (onStack.has(target)) {
-        lowLinks.set(node, Math.min(lowLinks.get(node) ?? 0, indexes.get(target) ?? 0));
-      }
-    }
-    if (lowLinks.get(node) === indexes.get(node)) {
-      const component = [];
-      let current;
-      do {
-        current = stack.pop();
-        if (current !== void 0) {
-          onStack.delete(current);
-          component.push(current);
-        }
-      } while (current !== node);
-      components.push(component);
-    }
-  }
-  for (const node of adjacency.keys()) {
-    if (!indexes.has(node)) {
-      connect(node);
-    }
-  }
-  return components.filter((component) => {
-    if (component.length > 1) {
-      return true;
-    }
-    const only = component[0];
-    return only !== void 0 && (adjacency.get(only) ?? []).includes(only);
-  });
-}
-function findCycle(component, adjacency) {
-  const members = new Set(component);
-  const visiting = /* @__PURE__ */ new Set();
-  const visited = /* @__PURE__ */ new Set();
-  const stack = [];
-  function visit(node) {
-    visiting.add(node);
-    stack.push(node);
-    for (const target of adjacency.get(node) ?? []) {
-      if (!members.has(target)) {
-        continue;
-      }
-      if (visiting.has(target)) {
-        return [...stack.slice(stack.indexOf(target)), target];
-      }
-      if (!visited.has(target)) {
-        const cycle = visit(target);
-        if (cycle !== void 0) {
-          return cycle;
-        }
-      }
-    }
-    stack.pop();
-    visiting.delete(node);
-    visited.add(node);
-    return void 0;
-  }
-  for (const node of component.toSorted()) {
-    const cycle = visit(node);
-    if (cycle !== void 0) {
-      return cycle;
-    }
-  }
-  return component;
-}
-function evaluateCycleRule(rule, subjects) {
-  const adjacency = adjacencyFor(subjects, rule);
-  return stronglyConnectedComponents(adjacency).map((component) => {
-    const cycle = findCycle(component, adjacency);
-    const first = cycle[0];
-    const source = first === void 0 ? void 0 : subjects.find(
-      (subject) => rule.collapseToFolderDepth === void 0 ? subject.path === first : collapsedPath(subject.path, rule.collapseToFolderDepth) === first
-    );
-    return makeViolation(rule, `Dependency cycle: ${cycle.join(" -> ")}.`, source);
-  });
-}
-function publicApiFile(fileName) {
-  const baseName = import_node_path5.default.basename(fileName);
-  return /^(?:index|public-api)\.[cm]?[jt]sx?$/u.test(baseName);
-}
-
-// src/analysis/evaluation/dependencies.ts
-function dependencyAllowed(rule, dependency) {
-  return (rule.dependencyKinds === void 0 || rule.dependencyKinds.includes(dependency.kind)) && (!rule.localOnly || dependency.resolution === "local");
-}
-function directDependencies(subject, rule) {
-  return subject.dependencies.filter((dependency) => dependencyAllowed(rule, dependency)).map((dependency) => ({ dependency, path: [subject.path, dependency.target] }));
-}
-function reachableDependencies(graph, subject, rule) {
-  if (!rule.transitive) {
-    return directDependencies(subject, rule);
-  }
-  const moduleByPath = new Map(
-    graph.modules.map((sourceModule) => [sourceModule.path, sourceModule])
-  );
-  const queue = [
-    {
-      module: subject,
-      path: [subject.path]
-    }
-  ];
-  const visited = /* @__PURE__ */ new Set([subject.path]);
-  const traversed = [];
-  while (queue.length > 0) {
-    const current = queue.shift();
-    if (current === void 0) {
-      continue;
-    }
-    for (const dependency of current.module.dependencies.filter(
-      (item) => dependencyAllowed(rule, item)
-    )) {
-      const dependencyPath = [...current.path, dependency.target];
-      traversed.push({ dependency, path: dependencyPath });
-      const target = moduleByPath.get(dependency.target);
-      if (target !== void 0 && !visited.has(target.path)) {
-        visited.add(target.path);
-        queue.push({ module: target, path: dependencyPath });
-      }
-    }
-  }
-  return traversed;
-}
-function incomingDependencies(graph, subject, rule) {
-  const direct = graph.dependencies.filter(
-    (dependency) => dependency.target === subject.path && dependencyAllowed(rule, dependency)
-  ).map((dependency) => ({ dependency, path: [dependency.from, subject.path] }));
-  if (!rule.transitive) {
-    return direct;
-  }
-  const incomingByTarget = /* @__PURE__ */ new Map();
-  for (const dependency of graph.dependencies.filter((item) => dependencyAllowed(rule, item))) {
-    const list = incomingByTarget.get(dependency.target) ?? [];
-    list.push(dependency);
-    incomingByTarget.set(dependency.target, list);
-  }
-  const queue = [
-    { path: [subject.path], target: subject.path }
-  ];
-  const visited = /* @__PURE__ */ new Set([subject.path]);
-  const traversed = [];
-  while (queue.length > 0) {
-    const current = queue.shift();
-    if (current === void 0) {
-      continue;
-    }
-    for (const dependency of incomingByTarget.get(current.target) ?? []) {
-      const dependencyPath = [dependency.from, ...current.path];
-      traversed.push({ dependency, path: dependencyPath });
-      if (!visited.has(dependency.from)) {
-        visited.add(dependency.from);
-        queue.push({ path: dependencyPath, target: dependency.from });
-      }
-    }
-  }
-  return traversed;
-}
-function sourceFor(graph, dependency) {
-  return graph.modules.find((candidate) => candidate.path === dependency.from);
-}
-function evaluateDependOn(graph, rule, subjects) {
-  const violations = [];
-  for (const subject of subjects) {
-    const traversed = reachableDependencies(graph, subject, rule);
-    const matching = traversed.filter(
-      ({ dependency }) => matchesSelector(dependency.target, rule.target) || rule.negated && dependency.target === "dynamic:unknown"
-    );
-    if (rule.negated) {
-      for (const item of matching) {
-        const message = item.dependency.target === "dynamic:unknown" ? `Cannot resolve computed dynamic import '${item.dependency.specifier}' to prove this boundary.` : `Imports '${item.dependency.specifier}', resolved as '${item.dependency.target}'.`;
-        violations.push(
-          makeViolation(
-            rule,
-            message,
-            sourceFor(graph, item.dependency),
-            item.dependency,
-            void 0,
-            item.path
-          )
-        );
-      }
-    } else if (matching.length === 0) {
-      violations.push(
-        makeViolation(rule, `Does not depend on ${formatSelector(rule.target)}.`, subject)
-      );
-    }
-  }
-  return violations;
-}
-function evaluateOnlyDependOn(graph, rule, subjects) {
-  const violations = [];
-  for (const subject of subjects) {
-    const outside = reachableDependencies(graph, subject, rule).filter(
-      ({ dependency }) => !matchesSelector(dependency.target, rule.target)
-    );
-    if (rule.negated) {
-      if (outside.length === 0) {
-        violations.push(
-          makeViolation(rule, `Every dependency matches ${formatSelector(rule.target)}.`, subject)
-        );
-      }
-    } else {
-      for (const item of outside) {
-        violations.push(
-          makeViolation(
-            rule,
-            `Imports '${item.dependency.specifier}', resolved as '${item.dependency.target}'.`,
-            sourceFor(graph, item.dependency),
-            item.dependency,
-            void 0,
-            item.path
-          )
-        );
-      }
-    }
-  }
-  return violations;
-}
-function evaluateDependedOnBy(graph, rule, subjects) {
-  const violations = [];
-  for (const subject of subjects) {
-    const matching = incomingDependencies(graph, subject, rule).filter(
-      ({ dependency }) => matchesSelector(dependency.from, rule.target)
-    );
-    if (rule.negated) {
-      for (const item of matching) {
-        violations.push(
-          makeViolation(
-            rule,
-            `'${item.dependency.from}' imports '${subject.path}'.`,
-            sourceFor(graph, item.dependency),
-            item.dependency,
-            void 0,
-            item.path
-          )
-        );
-      }
-    } else if (matching.length === 0) {
-      violations.push(
-        makeViolation(rule, `Is not depended on by ${formatSelector(rule.target)}.`, subject)
-      );
-    }
-  }
-  return violations;
-}
-function evaluateOnlyDependedOnBy(graph, rule, subjects) {
-  const violations = [];
-  for (const subject of subjects) {
-    const outside = incomingDependencies(graph, subject, rule).filter(
-      ({ dependency }) => !matchesSelector(dependency.from, rule.target)
-    );
-    if (rule.negated) {
-      if (outside.length === 0) {
-        violations.push(
-          makeViolation(
-            rule,
-            `Every incoming dependency is from ${formatSelector(rule.target)}.`,
-            subject
-          )
-        );
-      }
-    } else {
-      for (const item of outside) {
-        violations.push(
-          makeViolation(
-            rule,
-            `'${item.dependency.from}' imports '${subject.path}'.`,
-            sourceFor(graph, item.dependency),
-            item.dependency,
-            void 0,
-            item.path
-          )
-        );
-      }
-    }
-  }
-  return violations;
-}
-function evaluateDependencyRule(graph, rule, subjects) {
-  switch (rule.kind) {
-    case "depend-on":
-      return evaluateDependOn(graph, rule, subjects);
-    case "only-depend-on":
-      return evaluateOnlyDependOn(graph, rule, subjects);
-    case "depended-on-by":
-      return evaluateDependedOnBy(graph, rule, subjects);
-    case "only-depended-on-by":
-      return evaluateOnlyDependedOnBy(graph, rule, subjects);
-  }
-}
-
-// src/analysis/evaluation/semantic.ts
-var import_node_path6 = __toESM(require("path"), 1);
-function namedDeclarationViolation(rule, sourceModule, declaration, message) {
-  return makeViolation(rule, message, sourceModule, void 0, declaration);
-}
-function evaluateNameRule(rule, subjects) {
-  return subjects.flatMap((subject) => {
-    const fileName = import_node_path6.default.basename(subject.path);
-    const matches = rule.kind === "prefix" ? fileName.startsWith(rule.value) : fileName.endsWith(rule.value);
-    return matches !== rule.negated ? [] : [makeViolation(rule, `File name is '${fileName}'.`, subject)];
-  });
-}
-function evaluateLineCountRule(rule, subjects) {
-  return subjects.flatMap((subject) => {
-    const matches = subject.lines < rule.value;
-    return matches !== rule.negated ? [] : [makeViolation(rule, `File has ${subject.lines} lines.`, subject)];
-  });
-}
-function evaluateDeclarationKindRule(rule, subjects) {
-  return subjects.flatMap((subject) => {
-    if (subject.declarations.length === 0) {
-      return [makeViolation(rule, "File has no top-level declarations.", subject)];
-    }
-    return subject.declarations.flatMap((declaration) => {
-      const matches = declaration.kind === rule.declarationKind;
-      return matches !== rule.negated ? [] : [
-        namedDeclarationViolation(
-          rule,
-          subject,
-          declaration,
-          `'${declaration.name}' is a ${declaration.kind}, not a ${rule.declarationKind}.`
-        )
-      ];
-    });
-  });
-}
-function evaluateDeclarationModifierRule(rule, subjects) {
-  return subjects.flatMap((subject) => {
-    const declarations = subject.declarations.filter(
-      (declaration) => rule.kind === "exported" || declaration.kind === "class"
-    );
-    if (declarations.length === 0) {
-      return [
-        makeViolation(rule, `File has no declarations applicable to '${rule.kind}'.`, subject)
-      ];
-    }
-    return declarations.flatMap((declaration) => {
-      const matches = rule.kind === "abstract" ? declaration.abstract : subject.exports.includes(declaration.name) || declaration.defaultExport && subject.exports.includes("default");
-      return matches !== rule.negated ? [] : [
-        namedDeclarationViolation(
-          rule,
-          subject,
-          declaration,
-          `'${declaration.name}' is${matches ? "" : " not"} ${rule.kind}.`
-        )
-      ];
-    });
-  });
-}
-function evaluateHeritageRule(rule, subjects) {
-  return subjects.flatMap((subject) => {
-    const declarations = subject.declarations.filter(
-      (declaration) => declaration.kind === "class" || declaration.kind === "interface"
-    );
-    if (declarations.length === 0) {
-      return [makeViolation(rule, "File has no class or interface declarations.", subject)];
-    }
-    return declarations.flatMap((declaration) => {
-      const values = rule.kind === "extend" ? declaration.extends : declaration.implements;
-      const matches = values.some(
-        (value) => value === rule.value || value.endsWith(`.${rule.value}`)
-      );
-      return matches !== rule.negated ? [] : [
-        namedDeclarationViolation(
-          rule,
-          subject,
-          declaration,
-          `'${declaration.name}' ${rule.kind === "extend" ? "extends" : "implements"} ${values.join(", ") || "nothing"}.`
-        )
-      ];
-    });
-  });
-}
-function evaluateDecoratorRule(rule, subjects) {
-  return subjects.flatMap((subject) => {
-    const declarations = subject.declarations.filter((declaration) => declaration.kind === "class");
-    if (declarations.length === 0) {
-      return [makeViolation(rule, "File has no class declarations.", subject)];
-    }
-    return declarations.flatMap((declaration) => {
-      const matches = declaration.decorators.some(
-        (decorator) => decorator === rule.value || decorator.startsWith(`${rule.value}(`)
-      );
-      return matches !== rule.negated ? [] : [
-        namedDeclarationViolation(
-          rule,
-          subject,
-          declaration,
-          `'${declaration.name}' has decorators ${declaration.decorators.join(", ") || "none"}.`
-        )
-      ];
-    });
-  });
-}
-function evaluateExportRule(rule, subjects) {
-  return subjects.flatMap((subject) => {
-    const outside = subject.exports.filter((name) => !rule.names.includes(name));
-    if (rule.negated) {
-      return outside.length === 0 ? [
-        makeViolation(
-          rule,
-          `Every export matches ${rule.names.join(", ") || "nothing"}.`,
-          subject
-        )
-      ] : [];
-    }
-    return outside.map((name) => makeViolation(rule, `'${name}' is exported.`, subject));
-  });
-}
-function evaluateReadonlyRule(rule, subjects) {
-  return subjects.flatMap((subject) => {
-    const declarations = subject.declarations.filter((declaration) => declaration.kind === "class");
-    if (declarations.length === 0) {
-      return [makeViolation(rule, "File has no class declarations.", subject)];
-    }
-    return declarations.flatMap(
-      (declaration) => declaration.readonlyProperties !== rule.negated ? [] : [
-        namedDeclarationViolation(
-          rule,
-          subject,
-          declaration,
-          `'${declaration.name}' has mutable properties.`
-        )
-      ]
-    );
-  });
-}
-function evaluateStrictEqualityRule(rule, subjects) {
-  return subjects.flatMap(
-    (subject) => subject.uses.filter((use) => use.kind === "loose-equality").map(
-      (use) => makeViolation(rule, `Uses loose equality operator '${use.name}'.`, subject, void 0, use)
-    )
-  );
-}
-function evaluateGlobalUseRule(rule, subjects) {
-  return subjects.flatMap((subject) => {
-    const matching = subject.uses.filter(
-      (use) => use.kind === "call" && rule.globals.includes(use.name)
-    );
-    if (rule.negated) {
-      return matching.map(
-        (use) => makeViolation(rule, `Calls '${use.name}()'.`, subject, void 0, use)
-      );
-    }
-    const present = new Set(matching.map((use) => use.name));
-    return rule.globals.filter((name) => !present.has(name)).map((name) => makeViolation(rule, `Does not call '${name}()'.`, subject));
-  });
-}
-function matchesImportedFrom(actual, expected) {
-  return actual === expected || actual?.startsWith(`${expected}/`) === true;
-}
-function evaluateImportedSymbolUseRule(rule, subjects) {
-  return subjects.flatMap((subject) => {
-    const matching = subject.uses.filter(
-      (use) => use.kind === "call" && matchesImportedFrom(use.importedFrom, rule.importedFrom) && use.importedName !== void 0 && rule.symbols.includes(use.importedName)
-    );
-    if (rule.negated) {
-      return matching.map(
-        (use) => makeViolation(
-          rule,
-          `Calls '${use.name}()' imported as '${use.importedName}' from '${use.importedFrom}'.`,
-          subject,
-          void 0,
-          use
-        )
-      );
-    }
-    const present = new Set(matching.map((use) => use.importedName));
-    return rule.symbols.filter((symbol) => !present.has(symbol)).map(
-      (symbol) => makeViolation(
-        rule,
-        `Does not call '${symbol}()' imported from '${rule.importedFrom}'.`,
-        subject
-      )
-    );
-  });
-}
-function evaluateMethodRule(rule, subjects) {
-  return subjects.flatMap((subject) => {
-    const declarations = subject.declarations.filter(
-      (declaration) => declaration.kind === "class" || declaration.kind === "interface"
-    );
-    if (declarations.length === 0) {
-      return [makeViolation(rule, "File has no class or interface declarations.", subject)];
-    }
-    return declarations.flatMap((declaration) => {
-      const methods = declaration.methods.map((method) => method.name);
-      const matches = rule.kind === "only-public-methods" ? declaration.methods.every((method) => method.visibility === "public") && (rule.names.length === 0 || methods.every((method) => rule.names.includes(method))) : rule.kind === "have-visible-methods" ? rule.names.every(
-        (name) => declaration.methods.some(
-          (method) => method.name === name && method.visibility === rule.visibility
-        )
-      ) : rule.names.every((method) => methods.includes(method));
-      return matches !== rule.negated ? [] : [
-        namedDeclarationViolation(
-          rule,
-          subject,
-          declaration,
-          `'${declaration.name}' has methods ${methods.join(", ") || "none"}.`
-        )
-      ];
-    });
-  });
-}
-function evaluateResolutionRule(rule, subjects) {
-  return subjects.flatMap(
-    (subject) => subject.dependencies.filter(
-      (dependency) => !dependency.resolved && (!rule.allowDynamic || dependency.resolution !== "dynamic")
-    ).map(
-      (dependency) => makeViolation(rule, `Cannot resolve '${dependency.specifier}'.`, subject, dependency)
-    )
-  );
-}
-function evaluatePublicApiRule(rule, subjects) {
-  return subjects.flatMap((subject) => {
-    const matches = publicApiFile(subject.path);
-    return matches !== rule.negated ? [] : [makeViolation(rule, `'${import_node_path6.default.basename(subject.path)}' is not a public API file.`, subject)];
-  });
-}
-
-// src/analysis/evaluation/index.ts
-async function evaluateRule(graph, rule) {
-  const subjects = selectedModules(graph, rule.selection);
-  if (subjects.length === 0) {
-    return [noMatchViolation(rule)];
-  }
-  switch (rule.kind) {
-    case "depend-on":
-    case "only-depend-on":
-    case "depended-on-by":
-    case "only-depended-on-by":
-      return evaluateDependencyRule(graph, rule, subjects);
-    case "free-of-cycles":
-      return evaluateCycleRule(rule, subjects);
-    case "prefix":
-    case "suffix":
-      return evaluateNameRule(rule, subjects);
-    case "line-count-less-than":
-      return evaluateLineCountRule(rule, subjects);
-    case "declaration-kind":
-      return evaluateDeclarationKindRule(rule, subjects);
-    case "abstract":
-    case "exported":
-      return evaluateDeclarationModifierRule(rule, subjects);
-    case "extend":
-    case "implement":
-      return evaluateHeritageRule(rule, subjects);
-    case "decorator":
-      return evaluateDecoratorRule(rule, subjects);
-    case "only-export":
-      return evaluateExportRule(rule, subjects);
-    case "readonly-properties":
-      return evaluateReadonlyRule(rule, subjects);
-    case "strict-equality":
-      return evaluateStrictEqualityRule(rule, subjects);
-    case "use-globals":
-      return evaluateGlobalUseRule(rule, subjects);
-    case "use-imported-symbols":
-      return evaluateImportedSymbolUseRule(rule, subjects);
-    case "have-methods":
-    case "have-visible-methods":
-    case "only-public-methods":
-      return evaluateMethodRule(rule, subjects);
-    case "resolvable-dependencies":
-      return evaluateResolutionRule(rule, subjects);
-    case "public-api":
-      return evaluatePublicApiRule(rule, subjects);
-    case "custom": {
-      const result = await rule.evaluator({ graph, modules: subjects });
-      if (result === void 0) {
-        return [];
-      }
-      const violations = Array.isArray(result) ? [...result] : [result];
-      const normalized = [];
-      for (const violation2 of violations) {
-        normalized.push({
-          ...violation2,
-          ...rule.reason === void 0 ? {} : { reason: rule.reason },
-          ...rule.id === void 0 ? {} : { ruleId: rule.id },
-          severity: rule.severity
-        });
-      }
-      return normalized;
-    }
-  }
-}
-
-// src/engine/suite.ts
-var presets = /* @__PURE__ */ new Map();
-function metadata(values = {}) {
-  return {
-    ...values.id === void 0 ? {} : { id: values.id },
-    ...values.reason === void 0 ? {} : { reason: values.reason },
-    severity: values.severity ?? "error"
-  };
-}
-function countResult(graph, violations) {
-  const errors = violations.filter((item) => item.severity === "error").length;
-  const warnings = violations.filter((item) => item.severity === "warning").length;
-  const infos = violations.filter((item) => item.severity === "info").length;
-  return {
-    dependenciesAnalyzed: graph.dependencies.length,
-    errors,
-    filesAnalyzed: graph.modules.length,
-    infos,
-    ok: errors === 0,
-    violations,
-    warnings
-  };
-}
-var ArchitectureSuite = class {
-  options;
-  #rules = [];
-  #lastRule;
-  constructor(options = {}) {
-    this.options = options;
-  }
-  expect(selector) {
-    if (selectorValues(selector).length === 0) {
-      throw new TypeError("expect() needs at least one selector.");
-    }
-    return new ArchExpectation(this, { ignored: [], selector });
-  }
-  layers(definitions) {
-    return new ArchitectureLayers(this, definitions);
-  }
-  preset(name, options) {
-    applyPreset(name, this, options);
-    return this;
-  }
-  rule(id, evaluator, ruleMetadata = {}) {
-    this.add({
-      ...metadata({ ...ruleMetadata, id }),
-      evaluator,
-      kind: "custom",
-      selection: { ignored: [], selector: "**" }
-    });
-    return this;
-  }
-  add(rule) {
-    this.#rules.push(rule);
-    this.#lastRule = rule;
-  }
-  decorateLast(values) {
-    if (this.#lastRule === void 0) {
-      throw new TypeError("Declare a rule before adding metadata.");
-    }
-    if (values.id !== void 0) {
-      this.#lastRule.id = values.id;
-    }
-    if (values.reason !== void 0) {
-      this.#lastRule.reason = values.reason;
-    }
-    if (values.severity !== void 0) {
-      this.#lastRule.severity = values.severity;
-    }
-  }
-  async check(graph) {
-    const analyzed = graph ?? await analyze(this.options);
-    if (this.#rules.length === 0) {
-      return countResult(analyzed, [
-        {
-          message: "No architecture rules were declared.",
-          rule: "an architecture test must declare at least one rule",
-          severity: "error"
-        }
-      ]);
-    }
-    const groups = await Promise.all(this.#rules.map(async (rule) => evaluateRule(analyzed, rule)));
-    const violations = groups.flat().toSorted((left, right) => {
-      const fileComparison = (left.file ?? "").localeCompare(right.file ?? "");
-      if (fileComparison !== 0) {
-        return fileComparison;
-      }
-      const lineComparison = (left.line ?? 0) - (right.line ?? 0);
-      return lineComparison === 0 ? (left.ruleId ?? left.rule).localeCompare(right.ruleId ?? right.rule) : lineComparison;
-    });
-    return countResult(analyzed, violations);
-  }
-};
-var ArchExpectation = class {
-  #suite;
-  #selection;
-  #dependencyKinds;
-  #localOnly = false;
-  #negated = false;
-  #transitive = false;
-  constructor(suite, selection) {
-    this.#suite = suite;
-    this.#selection = selection;
-  }
-  get and() {
-    return this;
-  }
-  get not() {
-    this.#negated = !this.#negated;
-    return this;
-  }
-  expect(selector) {
-    return this.#suite.expect(selector);
-  }
-  ignoring(...selectors) {
-    this.#selection.ignored.push(...selectors);
-    return this;
-  }
-  includingDependencyKinds(...kinds) {
-    if (kinds.length === 0) {
-      throw new TypeError("includingDependencyKinds() needs at least one dependency kind.");
-    }
-    this.#dependencyKinds = [...new Set(kinds)];
-    return this;
-  }
-  runtimeDependencies() {
-    return this.includingDependencyKinds("static", "dynamic", "require");
-  }
-  typeDependencies() {
-    return this.includingDependencyKinds("type");
-  }
-  dynamicDependencies() {
-    return this.includingDependencyKinds("dynamic");
-  }
-  localDependencies() {
-    this.#localOnly = true;
-    return this;
-  }
-  transitively() {
-    this.#transitive = true;
-    return this;
-  }
-  toDependOn(target) {
-    this.addDependencyRule("depend-on", target);
-    return this;
-  }
-  toTransitivelyDependOn(target) {
-    return this.transitively().toDependOn(target);
-  }
-  toUse(target) {
-    return this.toDependOn(target);
-  }
-  toOnlyDependOn(target) {
-    this.addDependencyRule("only-depend-on", target);
-    return this;
-  }
-  toOnlyUse(target) {
-    return this.toOnlyDependOn(target);
-  }
-  toUseNothing() {
-    return this.toOnlyDependOn([]);
-  }
-  toBeDependedOnBy(target) {
-    this.addDependencyRule("depended-on-by", target);
-    return this;
-  }
-  toTransitivelyBeDependedOnBy(target) {
-    return this.transitively().toBeDependedOnBy(target);
-  }
-  toBeUsedIn(target) {
-    return this.toBeDependedOnBy(target);
-  }
-  toBeUsed() {
-    return this.toBeDependedOnBy("**");
-  }
-  toOnlyBeDependedOnBy(target) {
-    this.addDependencyRule("only-depended-on-by", target);
-    return this;
-  }
-  toOnlyBeUsedIn(target) {
-    return this.toOnlyBeDependedOnBy(target);
-  }
-  toBeFreeOfCycles(options = {}) {
-    if (this.consumeNegation()) {
-      throw new TypeError("toBeFreeOfCycles() cannot be negated.");
-    }
-    if (options.collapseToFolderDepth !== void 0 && options.collapseToFolderDepth < 1) {
-      throw new TypeError("collapseToFolderDepth must be a positive integer.");
-    }
-    this.#suite.add({
-      ...metadata(),
-      ...options,
-      kind: "free-of-cycles",
-      selection: this.#selection
-    });
-    return this;
-  }
-  toBeFreeOfFolderCycles(depth = 1) {
-    return this.toBeFreeOfCycles({ collapseToFolderDepth: depth });
-  }
-  toHavePrefix(value) {
-    this.addSimple({ kind: "prefix", negated: this.consumeNegation(), value });
-    return this;
-  }
-  toHaveSuffix(value) {
-    this.addSimple({ kind: "suffix", negated: this.consumeNegation(), value });
-    return this;
-  }
-  toHaveLineCountLessThan(value) {
-    if (!Number.isInteger(value) || value < 1) {
-      throw new TypeError("toHaveLineCountLessThan() needs a positive integer.");
-    }
-    this.addSimple({ kind: "line-count-less-than", negated: this.consumeNegation(), value });
-    return this;
-  }
-  toBeClasses() {
-    return this.addDeclarationKind("class");
-  }
-  toBeEnums() {
-    return this.addDeclarationKind("enum");
-  }
-  toBeFunctions() {
-    return this.addDeclarationKind("function");
-  }
-  toBeInterfaces() {
-    return this.addDeclarationKind("interface");
-  }
-  toBeTypes() {
-    return this.addDeclarationKind("type");
-  }
-  toBeAbstract() {
-    this.addSimple({ kind: "abstract", negated: this.consumeNegation() });
-    return this;
-  }
-  toBeExported() {
-    this.addSimple({ kind: "exported", negated: this.consumeNegation() });
-    return this;
-  }
-  toExtend(value) {
-    this.addSimple({ kind: "extend", negated: this.consumeNegation(), value });
-    return this;
-  }
-  toImplement(value) {
-    this.addSimple({ kind: "implement", negated: this.consumeNegation(), value });
-    return this;
-  }
-  toHaveDecorator(value) {
-    this.addSimple({ kind: "decorator", negated: this.consumeNegation(), value });
-    return this;
-  }
-  toOnlyExport(...names) {
-    this.addSimple({ kind: "only-export", names, negated: this.consumeNegation() });
-    return this;
-  }
-  toHaveReadonlyProperties() {
-    this.addSimple({ kind: "readonly-properties", negated: this.consumeNegation() });
-    return this;
-  }
-  toUseStrictEquality() {
-    if (this.consumeNegation()) {
-      throw new TypeError("toUseStrictEquality() cannot be negated.");
-    }
-    this.addSimple({ kind: "strict-equality" });
-    return this;
-  }
-  toUseGlobals(...globals) {
-    if (globals.length === 0) {
-      throw new TypeError("toUseGlobals() needs at least one global name.");
-    }
-    this.addSimple({ globals, kind: "use-globals", negated: this.consumeNegation() });
-    return this;
-  }
-  toUseImportedSymbols(importedFrom, ...symbols) {
-    if (importedFrom.trim() === "") {
-      throw new TypeError("toUseImportedSymbols() needs a module specifier.");
-    }
-    if (symbols.length === 0) {
-      throw new TypeError("toUseImportedSymbols() needs at least one imported symbol.");
-    }
-    this.addSimple({
-      importedFrom,
-      kind: "use-imported-symbols",
-      negated: this.consumeNegation(),
-      symbols
-    });
-    return this;
-  }
-  toHaveMethods(...names) {
-    if (names.length === 0) {
-      throw new TypeError("toHaveMethods() needs at least one method name.");
-    }
-    this.addSimple({ kind: "have-methods", names, negated: this.consumeNegation() });
-    return this;
-  }
-  toHavePublicMethods(...names) {
-    return this.addVisibleMethods("public", names);
-  }
-  toHaveProtectedMethods(...names) {
-    return this.addVisibleMethods("protected", names);
-  }
-  toHavePrivateMethods(...names) {
-    return this.addVisibleMethods("private", names);
-  }
-  toOnlyHavePublicMethods(...names) {
-    this.addSimple({ kind: "only-public-methods", names, negated: this.consumeNegation() });
-    return this;
-  }
-  toHaveResolvableDependencies(options = {}) {
-    if (this.consumeNegation()) {
-      throw new TypeError("toHaveResolvableDependencies() cannot be negated.");
-    }
-    this.addSimple({ allowDynamic: options.allowDynamic ?? false, kind: "resolvable-dependencies" });
-    return this;
-  }
-  toBePublicApi() {
-    this.addSimple({ kind: "public-api", negated: this.consumeNegation() });
-    return this;
-  }
-  toSatisfy(id, evaluator, ruleMetadata = {}) {
-    this.#suite.add({
-      ...metadata({ ...ruleMetadata, id }),
-      evaluator,
-      kind: "custom",
-      selection: this.#selection
-    });
-    this.#negated = false;
-    return this;
-  }
-  because(reason) {
-    this.#suite.decorateLast({ reason });
-    return this;
-  }
-  as(id) {
-    this.#suite.decorateLast({ id });
-    return this;
-  }
-  withSeverity(severity) {
-    this.#suite.decorateLast({ severity });
-    return this;
-  }
-  addDeclarationKind(declarationKind) {
-    this.addSimple({
-      declarationKind,
-      kind: "declaration-kind",
-      negated: this.consumeNegation()
-    });
-    return this;
-  }
-  addVisibleMethods(visibility2, names) {
-    if (names.length === 0) {
-      throw new TypeError(
-        `toHave${visibility2[0]?.toUpperCase() ?? ""}${visibility2.slice(1)}Methods() needs at least one method name.`
-      );
-    }
-    this.addSimple({
-      kind: "have-visible-methods",
-      names,
-      negated: this.consumeNegation(),
-      visibility: visibility2
-    });
-    return this;
-  }
-  addSimple(rule) {
-    this.#suite.add({ ...metadata(), ...rule, selection: this.#selection });
-  }
-  consumeNegation() {
-    const negated = this.#negated;
-    this.#negated = false;
-    return negated;
-  }
-  addDependencyRule(kind, target) {
-    this.#suite.add({
-      ...metadata(),
-      ...this.#dependencyKinds === void 0 ? {} : { dependencyKinds: this.#dependencyKinds },
-      kind,
-      localOnly: this.#localOnly,
-      negated: this.consumeNegation(),
-      selection: this.#selection,
-      target,
-      transitive: this.#transitive
-    });
-    this.#dependencyKinds = void 0;
-    this.#localOnly = false;
-    this.#transitive = false;
-  }
-};
-function createArcher(options = {}) {
-  return new ArchitectureSuite(options);
-}
-presets.set("strict", (suite) => {
-  suite.expect("**").toBeFreeOfCycles().as("strict/no-cycles").and.toHaveResolvableDependencies().as("strict/resolvable-dependencies").and.toUseStrictEquality().as("strict/strict-equality");
-});
-presets.set("node", (suite) => {
-  suite.expect("**").toHaveResolvableDependencies().as("node/resolvable-dependencies");
-  suite.expect("**").not.toDependOn(["node:domain", "node:punycode", "node:sys"]).as("node/no-deprecated-builtins");
-});
-presets.set("security", (suite) => {
-  suite.expect("**").not.toUseGlobals("eval", "Function").as("security/no-dynamic-code");
-});
-function registerPreset(name, preset) {
-  if (name.trim() === "") {
-    throw new TypeError("registerPreset() needs a non-empty name.");
-  }
-  presets.set(name, preset);
-}
-function applyPreset(name, suite, options) {
-  const preset = presets.get(name);
-  if (preset === void 0) {
-    throw new TypeError(`Unknown Archer preset '${name}'.`);
-  }
-  preset(suite, options);
-}
-function availablePresets() {
-  return [...presets.keys()].toSorted();
-}
-
-// src/reporting/format.ts
-function formatLocation(violation2) {
-  if (violation2.file === void 0) {
-    return "";
-  }
-  if (violation2.line === void 0) {
-    return violation2.file;
-  }
-  return `${violation2.file}:${violation2.line}:${violation2.column ?? 1}`;
-}
-function formatResult(result) {
-  if (result.violations.length === 0) {
-    return `Archer checked ${result.filesAnalyzed} files and ${result.dependenciesAnalyzed} dependencies.`;
-  }
-  const violations = result.violations.map((violation2) => {
-    const location = formatLocation(violation2);
-    const prefix = location.length > 0 ? `  ${location}
-` : "  ";
-    const source = violation2.sourceLine === void 0 ? "" : `
-    ${violation2.sourceLine.trim()}
-    ${" ".repeat(Math.max(0, (violation2.column ?? 1) - 1))}^`;
-    const chain = violation2.importChain === void 0 || violation2.importChain.length < 3 ? "" : `
-  Import chain: ${violation2.importChain.join(" -> ")}`;
-    const reason = violation2.reason === void 0 ? "" : `
-  Because: ${violation2.reason}`;
-    const id = violation2.ruleId === void 0 ? "" : ` [${violation2.ruleId}]`;
-    return `${prefix}  ${violation2.severity.toUpperCase()}${id}: ${violation2.message}${source}
-  Rule: ${violation2.rule}${reason}${chain}`;
-  });
-  return `${result.violations.length} architecture finding${result.violations.length === 1 ? "" : "s"}:
-
-${violations.join("\n\n")}`;
-}
-var ArchitectureError = class extends Error {
-  result;
-  constructor(result) {
-    super(formatResult(result));
-    this.name = "ArchitectureError";
-    this.result = result;
-  }
-};
-
-// src/reporting/reporters.ts
-function singleLine(value) {
-  return value.replaceAll(/\s+/gu, " ").trim();
-}
-function agent(result) {
-  const status = result.errors > 0 ? "fail" : result.warnings > 0 ? "warn" : result.infos > 0 ? "info" : "ok";
-  const summary = [
-    `archer: ${status}`,
-    `files=${result.filesAnalyzed}`,
-    `dependencies=${result.dependenciesAnalyzed}`,
-    `errors=${result.errors}`,
-    `warnings=${result.warnings}`,
-    `infos=${result.infos}`
-  ].join(" ");
-  const findings = result.violations.map((violation2) => {
-    const location = violation2.file === void 0 ? "architecture" : `${violation2.file}:${violation2.line ?? 1}:${violation2.column ?? 1}`;
-    const fields = [
-      `${location}: ${violation2.severity} ${singleLine(ruleKey(violation2))}: ${singleLine(violation2.message)}`,
-      `rule=${JSON.stringify(singleLine(violation2.rule))}`,
-      ...violation2.reason === void 0 ? [] : [`reason=${JSON.stringify(singleLine(violation2.reason))}`],
-      ...violation2.dependency === void 0 ? [] : [`dependency=${JSON.stringify(violation2.dependency)}`],
-      ...violation2.sourceLine === void 0 ? [] : [`source=${JSON.stringify(singleLine(violation2.sourceLine))}`],
-      ...violation2.importChain === void 0 ? [] : [`import_chain=${JSON.stringify(violation2.importChain)}`]
-    ];
-    return fields.join(" | ");
-  });
-  return [summary, ...findings].join("\n");
-}
-function sarifLevel(severity) {
-  return severity === "info" ? "note" : severity;
-}
-function ruleKey(violation2) {
-  return violation2.ruleId ?? violation2.rule;
-}
-function sarif(result) {
-  const rules = [
-    ...new Map(
-      result.violations.map((violation2) => [
-        ruleKey(violation2),
-        {
-          id: ruleKey(violation2),
-          shortDescription: { text: violation2.rule }
-        }
-      ])
-    ).values()
-  ];
-  const results = result.violations.map((violation2) => ({
-    level: sarifLevel(violation2.severity),
-    message: { text: violation2.message },
-    ...violation2.file === void 0 ? {} : {
-      locations: [
-        {
-          physicalLocation: {
-            artifactLocation: { uri: violation2.file },
-            ...violation2.line === void 0 ? {} : {
-              region: {
-                startColumn: violation2.column ?? 1,
-                startLine: violation2.line
-              }
-            }
-          }
-        }
-      ]
-    },
-    ruleId: ruleKey(violation2)
-  }));
-  return JSON.stringify(
-    {
-      $schema: "https://json.schemastore.org/sarif-2.1.0.json",
-      runs: [{ results, tool: { driver: { name: "Archer", rules } } }],
-      version: "2.1.0"
-    },
-    void 0,
-    2
-  );
-}
-function annotationValue(value) {
-  return value.replaceAll("%", "%25").replaceAll("\r", "%0D").replaceAll("\n", "%0A").replaceAll(":", "%3A").replaceAll(",", "%2C");
-}
-function github(result) {
-  if (result.violations.length === 0) {
-    return formatResult(result);
-  }
-  return result.violations.map((violation2) => {
-    const level = violation2.severity === "info" ? "notice" : violation2.severity;
-    const attributes = [
-      ...violation2.file === void 0 ? [] : [`file=${annotationValue(violation2.file)}`],
-      ...violation2.line === void 0 ? [] : [`line=${violation2.line}`],
-      ...violation2.column === void 0 ? [] : [`col=${violation2.column}`],
-      `title=${annotationValue(ruleKey(violation2))}`
-    ];
-    return `::${level} ${attributes.join(",")}::${annotationValue(violation2.message)}`;
-  }).join("\n");
-}
-function dotEscape(value) {
-  return value.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
-}
-function dot(graph) {
-  const lines = ["digraph archer {", "  rankdir=LR;"];
-  for (const sourceModule of graph.modules) {
-    lines.push(`  "${dotEscape(sourceModule.path)}" [shape=box];`);
-  }
-  for (const dependency of graph.dependencies) {
-    const style = dependency.kind === "type" ? ",style=dashed" : "";
-    lines.push(
-      `  "${dotEscape(dependency.from)}" -> "${dotEscape(dependency.target)}" [label="${dependency.kind}"${style}];`
-    );
-  }
-  lines.push("}");
-  return lines.join("\n");
-}
-function report(name, result, graph) {
-  switch (name) {
-    case "agent":
-    case "llm":
-      return agent(result);
-    case "pretty":
-      return formatResult(result);
-    case "json":
-      return JSON.stringify(result, void 0, 2);
-    case "sarif":
-      return sarif(result);
-    case "github":
-      return github(result);
-    case "dot":
-      if (graph === void 0) {
-        throw new TypeError("The DOT reporter needs an architecture graph.");
-      }
-      return dot(graph);
-  }
-}
-
-// src/testing/matchers.ts
-function isArchitectureCheck(value) {
-  return typeof value === "object" && value !== null && "check" in value && typeof value.check === "function";
-}
-async function toRespectArchitecture(received) {
-  if (!isArchitectureCheck(received)) {
-    throw new TypeError(
-      "toRespectArchitecture() expects an Archer suite created by createArcher() or arch()."
-    );
-  }
-  const result = await received.check();
-  return {
-    pass: result.ok,
-    message: () => result.ok ? "Expected the architecture check to report at least one finding." : formatResult(result)
-  };
-}
-var archerMatchers = { toRespectArchitecture };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ArchExpectation,
-  ArchitectureError,
-  ArchitectureLayers,
-  ArchitectureSuite,
-  LayerExpectation,
-  analyze,
-  applyBaseline,
-  applyPreset,
-  archerMatchers,
-  availablePresets,
-  clearAnalysisCache,
-  createArcher,
-  createBaseline,
-  defineConfig,
-  formatResult,
-  readBaseline,
-  registerPreset,
-  report,
-  violationFingerprint,
-  writeBaseline
-});