@standards-kit/conform 0.1.0

package/dist/chunk-KHO6NIAI.js

@@ -0,0 +1,1367 @@
+// ../core/src/registry.ts
+import * as fs2 from "fs";
+import * as os from "os";
+import * as path2 from "path";
+import * as toml from "@iarna/toml";
+import { execa } from "execa";
+
+// ../core/src/loader.ts
+import * as fs from "fs";
+import * as path from "path";
+import TOML from "@iarna/toml";
+
+// ../core/src/schema.ts
+import { minimatch } from "minimatch";
+import { z } from "zod";
+function countUnclosedDelimiters(pattern) {
+  let brackets = 0;
+  let braces = 0;
+  for (let i = 0; i < pattern.length; i++) {
+    if (pattern[i] === "\\" && i + 1 < pattern.length) {
+      i++;
+      continue;
+    }
+    switch (pattern[i]) {
+      case "[":
+        brackets++;
+        break;
+      case "]":
+        if (brackets > 0) {
+          brackets--;
+        }
+        break;
+      case "{":
+        braces++;
+        break;
+      case "}":
+        if (braces > 0) {
+          braces--;
+        }
+        break;
+    }
+  }
+  return { brackets, braces };
+}
+function isValidGlobPattern(pattern) {
+  if (pattern.length === 0) {
+    return { valid: false, error: "empty pattern" };
+  }
+  const unclosed = countUnclosedDelimiters(pattern);
+  if (unclosed.brackets > 0) {
+    return { valid: false, error: "unclosed bracket '['" };
+  }
+  if (unclosed.braces > 0) {
+    return { valid: false, error: "unclosed brace '{'" };
+  }
+  try {
+    const result = minimatch.makeRe(pattern);
+    return result === false ? { valid: false, error: "invalid pattern syntax" } : { valid: true };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Invalid glob pattern";
+    return { valid: false, error: message };
+  }
+}
+var globPatternSchema = z.string().refine(
+  (pattern) => isValidGlobPattern(pattern).valid,
+  (pattern) => ({
+    message: `Invalid glob pattern: "${pattern}" - ${isValidGlobPattern(pattern).error}`
+  })
+);
+var eslintRuleSeverity = z.enum(["off", "warn", "error"]);
+var eslintRuleWithOptions = z.object({
+  severity: eslintRuleSeverity
+}).catchall(z.unknown());
+var eslintRuleValue = z.union([eslintRuleSeverity, eslintRuleWithOptions]);
+var eslintRulesSchema = z.record(z.string(), eslintRuleValue).optional();
+var eslintConfigSchema = z.object({
+  enabled: z.boolean().optional().default(true),
+  files: z.array(z.string()).optional(),
+  // Glob patterns for files to lint
+  ignore: z.array(z.string()).optional(),
+  // Glob patterns to ignore
+  "max-warnings": z.number().int().nonnegative().optional(),
+  // Max warnings before failure
+  rules: eslintRulesSchema,
+  // Required rules for audit (verifies eslint.config.js)
+  dependencies: z.array(z.string()).optional()
+  // Custom dependency files for drift tracking
+}).strict().optional();
+var ruffLintSchema = z.object({
+  select: z.array(z.string()).optional(),
+  ignore: z.array(z.string()).optional()
+}).strict().optional();
+var ruffConfigSchema = z.object({
+  enabled: z.boolean().optional().default(true),
+  "line-length": z.number().int().positive().optional(),
+  lint: ruffLintSchema,
+  dependencies: z.array(z.string()).optional()
+  // Custom dependency files for drift tracking
+}).strict().optional();
+var tscCompilerOptionsSchema = z.object({
+  strict: z.boolean().optional(),
+  noImplicitAny: z.boolean().optional(),
+  strictNullChecks: z.boolean().optional(),
+  noUnusedLocals: z.boolean().optional(),
+  noUnusedParameters: z.boolean().optional(),
+  noImplicitReturns: z.boolean().optional(),
+  noFallthroughCasesInSwitch: z.boolean().optional(),
+  esModuleInterop: z.boolean().optional(),
+  skipLibCheck: z.boolean().optional(),
+  forceConsistentCasingInFileNames: z.boolean().optional()
+}).strict().optional();
+var tscConfigSchema = z.object({
+  enabled: z.boolean().optional().default(false),
+  require: tscCompilerOptionsSchema,
+  // Required compiler options for audit
+  dependencies: z.array(z.string()).optional()
+  // Custom dependency files for drift tracking
+}).strict().optional();
+var tyConfigSchema = z.object({
+  enabled: z.boolean().optional().default(false),
+  dependencies: z.array(z.string()).optional()
+  // Custom dependency files for drift tracking
+}).strict().optional();
+var knipConfigSchema = z.object({
+  enabled: z.boolean().optional().default(false),
+  dependencies: z.array(z.string()).optional()
+  // Custom dependency files for drift tracking
+}).strict().optional();
+var vultureConfigSchema = z.object({
+  enabled: z.boolean().optional().default(false),
+  dependencies: z.array(z.string()).optional()
+  // Custom dependency files for drift tracking
+}).strict().optional();
+var coverageRunnerSchema = z.enum(["vitest", "jest", "pytest", "auto"]);
+var coverageRunConfigSchema = z.object({
+  enabled: z.boolean().optional().default(false),
+  min_threshold: z.number().int().min(0).max(100).optional().default(80),
+  // Minimum coverage percentage
+  runner: coverageRunnerSchema.optional().default("auto"),
+  // Test runner to use
+  command: z.string().optional(),
+  // Custom command to run tests with coverage
+  dependencies: z.array(z.string()).optional()
+  // Custom dependency files for drift tracking
+}).strict().optional();
+var secretsConfigSchema = z.object({
+  enabled: z.boolean().optional().default(false),
+  scan_mode: z.enum(["branch", "files", "staged", "full"]).optional().default("branch"),
+  // branch: scan current branch commits, files: scan filesystem, staged: staged files only, full: entire git history
+  base_branch: z.string().optional().default("main"),
+  // Branch to compare against for "branch" mode
+  dependencies: z.array(z.string()).optional()
+  // Custom dependency files for drift tracking
+}).strict().optional();
+var pnpmauditConfigSchema = z.object({
+  enabled: z.boolean().optional().default(false),
+  exclude_dev: z.boolean().optional().default(true),
+  dependencies: z.array(z.string()).optional()
+  // Custom dependency files for drift tracking
+}).strict().optional();
+var pipauditConfigSchema = z.object({
+  enabled: z.boolean().optional().default(false),
+  dependencies: z.array(z.string()).optional()
+  // Custom dependency files for drift tracking
+}).strict().optional();
+var codeSecuritySchema = z.object({
+  secrets: secretsConfigSchema,
+  pnpmaudit: pnpmauditConfigSchema,
+  pipaudit: pipauditConfigSchema
+}).strict().optional();
+var caseTypeSchema = z.enum(["kebab-case", "snake_case", "camelCase", "PascalCase"]);
+var uniqueArraySchema = (schema) => z.array(schema).refine((arr) => new Set(arr).size === arr.length, {
+  message: "Duplicate values not allowed"
+});
+var uniqueArraySchemaMin1 = (schema) => z.array(schema).min(1, "At least one value is required").refine((arr) => new Set(arr).size === arr.length, {
+  message: "Duplicate values not allowed"
+});
+var namingRuleSchema = z.object({
+  extensions: uniqueArraySchemaMin1(z.string()),
+  // e.g., ["ts", "tsx"] - no duplicates allowed, at least one required
+  file_case: caseTypeSchema,
+  folder_case: caseTypeSchema,
+  exclude: z.array(z.string()).optional(),
+  // Glob patterns to exclude, e.g., ["tests/**"]
+  allow_dynamic_routes: z.boolean().optional()
+  // Allow Next.js/Remix dynamic route folders: [id], [...slug], (group)
+}).strict();
+var namingConfigSchema = z.object({
+  enabled: z.boolean().optional().default(false),
+  rules: z.array(namingRuleSchema).optional()
+}).strict().superRefine((data, ctx) => {
+  if (!data.rules || data.rules.length <= 1) {
+    return;
+  }
+  const extensionToRuleIndex = /* @__PURE__ */ new Map();
+  for (let i = 0; i < data.rules.length; i++) {
+    for (const ext of data.rules[i].extensions) {
+      const existing = extensionToRuleIndex.get(ext);
+      if (existing !== void 0) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `Extension "${ext}" appears in multiple naming rules (rules ${existing + 1} and ${i + 1}). Each extension can only appear in one rule.`,
+          path: ["rules", i, "extensions"]
+        });
+      } else {
+        extensionToRuleIndex.set(ext, i);
+      }
+    }
+  }
+}).optional();
+var disableCommentsConfigSchema = z.object({
+  enabled: z.boolean().optional().default(false),
+  patterns: z.array(z.string()).optional(),
+  // Override default patterns
+  extensions: uniqueArraySchema(z.string()).optional(),
+  // File extensions to scan - no duplicates allowed
+  exclude: z.array(z.string()).optional()
+  // Glob patterns to exclude
+}).strict().optional();
+var codeQualitySchema = z.object({
+  "disable-comments": disableCommentsConfigSchema
+}).strict().optional();
+var codeLintingSchema = z.object({
+  eslint: eslintConfigSchema,
+  ruff: ruffConfigSchema
+}).strict().optional();
+var codeTypesSchema = z.object({
+  tsc: tscConfigSchema,
+  ty: tyConfigSchema
+}).strict().optional();
+var codeUnusedSchema = z.object({
+  knip: knipConfigSchema,
+  vulture: vultureConfigSchema
+}).strict().optional();
+var codeSchema = z.object({
+  linting: codeLintingSchema,
+  types: codeTypesSchema,
+  unused: codeUnusedSchema,
+  coverage_run: coverageRunConfigSchema,
+  security: codeSecuritySchema,
+  naming: namingConfigSchema,
+  quality: codeQualitySchema
+}).strict().optional();
+var hookCommandsSchema = z.record(z.string(), z.array(z.string())).optional();
+var hooksConfigSchema = z.object({
+  enabled: z.boolean().optional().default(false),
+  require_husky: z.boolean().optional().default(true),
+  // Require .husky/ directory
+  require_hooks: z.array(z.string()).optional(),
+  // e.g., ["pre-commit", "pre-push"]
+  commands: hookCommandsSchema,
+  // e.g., { "pre-commit": ["lint-staged"] }
+  protected_branches: z.array(z.string()).optional()
+  // e.g., ["main", "master"] - verify pre-push prevents direct pushes
+}).strict().optional();
+var ciCommandsValueSchema = z.union([
+  z.array(z.string()),
+  // Workflow-level: ["cmd1", "cmd2"]
+  z.record(z.string(), z.array(z.string()))
+  // Job-level: { jobName: ["cmd1"] }
+]);
+var ciCommandsSchema = z.record(z.string(), ciCommandsValueSchema).optional();
+var ciConfigSchema = z.object({
+  enabled: z.boolean().optional().default(false),
+  require_workflows: z.array(z.string()).optional(),
+  // e.g., ["ci.yml", "release.yml"]
+  jobs: z.record(z.string(), z.array(z.string())).optional(),
+  // e.g., { "ci.yml": ["test", "lint"] }
+  actions: z.record(z.string(), z.array(z.string())).optional(),
+  // e.g., { "ci.yml": ["actions/checkout"] }
+  commands: ciCommandsSchema
+  // e.g., { "ci.yml": ["conform code check"] } or { "ci.yml": { "test": ["npm test"] } }
+}).strict().optional();
+var branchesConfigSchema = z.object({
+  enabled: z.boolean().optional().default(false),
+  pattern: z.string().optional(),
+  // Regex pattern for branch names
+  exclude: z.array(z.string()).optional(),
+  // Branches to skip (e.g., ["main", "master"])
+  require_issue: z.boolean().optional().default(false),
+  // Require issue number in branch name
+  issue_pattern: z.string().optional()
+  // Regex to extract issue number (default: captures number after type/)
+}).strict().optional();
+var commitsConfigSchema = z.object({
+  enabled: z.boolean().optional().default(false),
+  pattern: z.string().optional(),
+  // Regex pattern for commit messages (e.g., conventional commits)
+  types: z.array(z.string()).optional(),
+  // Allowed commit types (e.g., ["feat", "fix", "chore"])
+  require_scope: z.boolean().optional().default(false),
+  // Require scope like feat(api): ...
+  max_subject_length: z.number().int().positive().optional()
+  // Max length of subject line
+}).strict().optional();
+var changesetBumpTypeSchema = z.enum(["patch", "minor", "major"]);
+var changesetsConfigSchema = z.object({
+  enabled: z.boolean().optional().default(false),
+  require_for_paths: z.array(z.string()).optional(),
+  // Glob patterns that require changesets (e.g., ["src/**"])
+  exclude_paths: z.array(z.string()).optional(),
+  // Paths that don't require changesets (e.g., ["**/*.test.ts"])
+  validate_format: z.boolean().optional().default(true),
+  // Validate changeset file format (frontmatter, description)
+  allowed_bump_types: z.array(changesetBumpTypeSchema).optional(),
+  // Restrict allowed bump types (e.g., ["patch", "minor"])
+  require_description: z.boolean().optional().default(true),
+  // Require non-empty description
+  min_description_length: z.number().int().positive().optional()
+  // Minimum description length
+}).strict().optional();
+var prConfigSchema = z.object({
+  enabled: z.boolean().optional().default(false),
+  max_files: z.number().int().positive().optional(),
+  // Max files changed in PR
+  max_lines: z.number().int().positive().optional(),
+  // Max lines changed (additions + deletions)
+  require_issue: z.boolean().optional().default(false),
+  // Require issue reference in PR description
+  issue_keywords: z.array(z.string()).optional(),
+  // Keywords that link to issues (e.g., ["Closes", "Fixes", "Resolves"])
+  exclude: z.array(globPatternSchema).optional()
+  // Glob patterns to exclude from size calculation (e.g., ["*.lock", "**/*.snap"])
+}).strict().optional();
+var ticketsConfigSchema = z.object({
+  enabled: z.boolean().optional().default(false),
+  pattern: z.string().optional(),
+  // Regex pattern for ticket IDs (e.g., "^(ABC|XYZ)-[0-9]+")
+  require_in_commits: z.boolean().optional().default(true),
+  // Require ticket in commit messages
+  require_in_branch: z.boolean().optional().default(false)
+  // Require ticket in branch name
+}).strict().optional();
+var coverageEnforceInSchema = z.enum(["ci", "config", "both"]);
+var coverageConfigSchema = z.object({
+  enabled: z.boolean().optional().default(false),
+  min_threshold: z.number().int().min(0).max(100).optional(),
+  // Minimum coverage percentage
+  enforce_in: coverageEnforceInSchema.optional().default("config"),
+  // Where to verify coverage
+  ci_workflow: z.string().optional(),
+  // Workflow file to check (e.g., "ci.yml")
+  ci_job: z.string().optional()
+  // Job name to check (e.g., "test")
+}).strict().optional();
+var bypassActorTypeSchema = z.enum([
+  "Integration",
+  // GitHub App
+  "OrganizationAdmin",
+  // Org admin role
+  "RepositoryRole",
+  // Repository role (1=read, 2=triage, 3=write, 4=maintain, 5=admin)
+  "Team",
+  // GitHub team
+  "DeployKey"
+  // Deploy key
+]);
+var bypassModeSchema = z.enum([
+  "always",
+  // Can always bypass
+  "pull_request"
+  // Can bypass only via pull request
+]);
+var bypassActorSchema = z.object({
+  actor_type: bypassActorTypeSchema,
+  actor_id: z.number().int().positive().optional(),
+  // Actor ID (required except for DeployKey)
+  bypass_mode: bypassModeSchema.optional().default("always")
+}).strict();
+var rulesetConfigSchema = z.object({
+  name: z.string().optional().default("Branch Protection"),
+  // Ruleset name in GitHub
+  branch: z.string().optional().default("main"),
+  // Branch to check (default: main)
+  enforcement: z.enum(["active", "evaluate", "disabled"]).optional().default("active"),
+  // Ruleset enforcement
+  required_reviews: z.number().int().min(0).optional(),
+  // Minimum required reviews
+  dismiss_stale_reviews: z.boolean().optional(),
+  // Dismiss stale reviews on new commits
+  require_code_owner_reviews: z.boolean().optional(),
+  // Require CODEOWNER review
+  require_status_checks: z.array(z.string()).optional(),
+  // Required status checks
+  require_branches_up_to_date: z.boolean().optional(),
+  // Require branch to be up to date
+  require_signed_commits: z.boolean().optional(),
+  // Require signed commits
+  enforce_admins: z.boolean().optional(),
+  // Enforce rules for admins (no bypass actors when true)
+  bypass_actors: z.array(bypassActorSchema).optional()
+  // Actors that can bypass rules
+}).strict().optional();
+var tagProtectionConfigSchema = z.object({
+  patterns: z.array(z.string()).optional(),
+  // Tag patterns to protect (e.g., ["v*"])
+  prevent_deletion: z.boolean().optional().default(true),
+  // Prevent tag deletion
+  prevent_update: z.boolean().optional().default(true)
+  // Prevent tag updates (force-push)
+}).strict().optional();
+var repoConfigSchema = z.object({
+  enabled: z.boolean().optional().default(false),
+  require_branch_protection: z.boolean().optional().default(false),
+  // Check branch protection exists
+  require_codeowners: z.boolean().optional().default(false),
+  // Check CODEOWNERS file exists
+  ruleset: rulesetConfigSchema,
+  // GitHub Ruleset configuration
+  tag_protection: tagProtectionConfigSchema
+  // Tag protection via GitHub rulesets
+}).strict().optional();
+var backupsConfigSchema = z.object({
+  enabled: z.boolean().optional().default(false),
+  bucket: z.string().optional(),
+  // S3 bucket name
+  prefix: z.string().optional(),
+  // S3 key prefix
+  max_age_hours: z.number().int().positive().optional().default(24),
+  // Max age of most recent backup
+  region: z.string().optional()
+  // AWS region (defaults to AWS_REGION env)
+}).strict().optional();
+var codeownersRuleSchema = z.object({
+  pattern: z.string(),
+  // File pattern (e.g., "/standards.toml", "*.js", "/src/api/*")
+  owners: z.array(z.string())
+  // Owner handles (e.g., ["@user", "@org/team"])
+}).strict();
+var codeownersConfigSchema = z.object({
+  enabled: z.boolean().optional().default(false),
+  rules: z.array(codeownersRuleSchema).optional()
+  // Required rules in CODEOWNERS
+}).strict().optional();
+var docsTypeConfigSchema = z.object({
+  required_sections: z.array(z.string()).optional(),
+  // e.g., ["Overview", "Parameters", "Returns", "Examples"]
+  frontmatter: z.array(z.string()).optional()
+  // e.g., ["title", "tracks"]
+}).strict();
+var docsEnforcementSchema = z.enum(["block", "warn"]);
+var docsConfigSchema = z.object({
+  enabled: z.boolean().optional().default(false),
+  path: z.string().optional().default("docs/"),
+  // Documentation directory
+  enforcement: docsEnforcementSchema.optional().default("warn"),
+  // "block" or "warn"
+  allowlist: z.array(z.string()).optional(),
+  // Markdown files allowed outside docs/, e.g., ["README.md", "CLAUDE.md"]
+  max_files: z.number().int().positive().optional(),
+  // Max markdown files in docs/
+  max_file_lines: z.number().int().positive().optional(),
+  // Max lines per markdown file
+  max_total_kb: z.number().int().positive().optional(),
+  // Max total size of docs/
+  staleness_days: z.number().int().positive().optional().default(30),
+  // Days before doc is considered stale
+  stale_mappings: z.record(z.string(), z.string()).optional(),
+  // Override doc-to-source mappings
+  min_coverage: z.number().int().min(0).max(100).optional(),
+  // Minimum API coverage percentage
+  coverage_paths: z.array(z.string()).optional(),
+  // Glob patterns for source files, e.g., ["src/**/*.ts"]
+  exclude_patterns: z.array(z.string()).optional(),
+  // Exclude from coverage, e.g., ["**/*.test.ts"]
+  types: z.record(z.string(), docsTypeConfigSchema).optional()
+  // Per-type config, e.g., { api: {...}, guide: {...} }
+}).strict().optional();
+var mcpStandardsSchema = z.object({
+  source: z.string().optional().describe(
+    'Standards repository source: "github:owner/repo", "github:owner/repo@ref", or local path'
+  )
+}).strict().optional();
+var mcpSchema = z.object({
+  standards: mcpStandardsSchema
+}).strict().optional();
+var infraSchema = z.object({
+  enabled: z.boolean().optional().default(false),
+  manifest: z.string().optional().default("infra-manifest.json")
+  // Path to manifest file
+}).strict().optional();
+var DEFAULT_FORBIDDEN_FILES_IGNORE = ["**/node_modules/**", "**/.git/**"];
+var forbiddenFilesConfigSchema = z.object({
+  enabled: z.boolean().optional().default(false),
+  files: z.array(globPatternSchema).optional(),
+  // Glob patterns for files that must not exist (validated)
+  ignore: z.array(globPatternSchema).optional(),
+  // Glob patterns to ignore (validated, overrides defaults if provided)
+  message: z.string().optional()
+  // Custom message explaining why these files are forbidden
+}).strict().optional();
+var processSchema = z.object({
+  hooks: hooksConfigSchema,
+  ci: ciConfigSchema,
+  branches: branchesConfigSchema,
+  commits: commitsConfigSchema,
+  changesets: changesetsConfigSchema,
+  pr: prConfigSchema,
+  tickets: ticketsConfigSchema,
+  coverage: coverageConfigSchema,
+  repo: repoConfigSchema,
+  backups: backupsConfigSchema,
+  codeowners: codeownersConfigSchema,
+  docs: docsConfigSchema,
+  forbidden_files: forbiddenFilesConfigSchema
+}).strict().optional();
+var extendsSchema = z.object({
+  registry: z.string(),
+  // e.g., "github:myorg/standards" or local path
+  rulesets: z.array(z.string())
+  // e.g., ["base", "typescript"]
+}).strict().optional();
+var monorepoSchema = z.object({
+  exclude: z.array(globPatternSchema).optional()
+  // Glob patterns to exclude from project detection
+}).strict().optional();
+var configSchema = z.object({
+  extends: extendsSchema,
+  code: codeSchema,
+  process: processSchema,
+  infra: infraSchema,
+  mcp: mcpSchema,
+  monorepo: monorepoSchema
+}).strict();
+var defaultConfig = {
+  code: {
+    linting: {
+      eslint: { enabled: false },
+      ruff: { enabled: false }
+    },
+    types: {
+      tsc: { enabled: false },
+      ty: { enabled: false }
+    },
+    unused: {
+      knip: { enabled: false },
+      vulture: { enabled: false }
+    },
+    coverage_run: {
+      enabled: false,
+      min_threshold: 80,
+      runner: "auto"
+    },
+    security: {
+      secrets: { enabled: false, scan_mode: "branch", base_branch: "main" },
+      pnpmaudit: { enabled: false, exclude_dev: true },
+      pipaudit: { enabled: false }
+    },
+    naming: {
+      enabled: false
+    },
+    quality: {
+      "disable-comments": { enabled: false }
+    }
+  },
+  monorepo: {},
+  process: {
+    hooks: {
+      enabled: false,
+      require_husky: true
+    },
+    ci: {
+      enabled: false
+    },
+    branches: {
+      enabled: false,
+      require_issue: false
+    },
+    commits: {
+      enabled: false,
+      require_scope: false
+    },
+    changesets: {
+      enabled: false,
+      validate_format: true,
+      require_description: true
+    },
+    pr: {
+      enabled: false,
+      require_issue: false
+    },
+    tickets: {
+      enabled: false,
+      require_in_commits: true,
+      require_in_branch: false
+    },
+    coverage: {
+      enabled: false,
+      enforce_in: "config"
+    },
+    repo: {
+      enabled: false,
+      require_branch_protection: false,
+      require_codeowners: false
+    },
+    backups: {
+      enabled: false,
+      max_age_hours: 24
+    },
+    codeowners: {
+      enabled: false
+    },
+    docs: {
+      enabled: false,
+      path: "docs/",
+      enforcement: "warn",
+      staleness_days: 30
+    },
+    forbidden_files: {
+      enabled: false
+    }
+  },
+  infra: {
+    enabled: false,
+    manifest: "infra-manifest.json"
+  },
+  mcp: {
+    standards: {
+      source: void 0
+    }
+  }
+};
+
+// ../core/src/loader.ts
+var CONFIG_FILE_NAME = "standards.toml";
+var ConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigError";
+  }
+};
+function isBrokenSymlink(filePath) {
+  try {
+    const stats = fs.lstatSync(filePath);
+    if (stats.isSymbolicLink()) {
+      try {
+        fs.statSync(filePath);
+        return false;
+      } catch {
+        return true;
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function findConfigFile(startDir = process.cwd()) {
+  let currentDir = path.resolve(startDir);
+  const root = path.parse(currentDir).root;
+  while (currentDir !== root) {
+    const configPath = path.join(currentDir, CONFIG_FILE_NAME);
+    if (isBrokenSymlink(configPath)) {
+      throw new ConfigError(`${CONFIG_FILE_NAME} exists but is a broken symlink: ${configPath}`);
+    }
+    if (fs.existsSync(configPath)) {
+      return configPath;
+    }
+    currentDir = path.dirname(currentDir);
+  }
+  const rootConfig = path.join(root, CONFIG_FILE_NAME);
+  if (isBrokenSymlink(rootConfig)) {
+    throw new ConfigError(`${CONFIG_FILE_NAME} exists but is a broken symlink: ${rootConfig}`);
+  }
+  return fs.existsSync(rootConfig) ? rootConfig : null;
+}
+function resolveConfigPath(configPath) {
+  const resolved = configPath ?? findConfigFile();
+  if (!resolved) {
+    throw new ConfigError(`No ${CONFIG_FILE_NAME} found. Create one or specify --config path.`);
+  }
+  const absolutePath = path.resolve(resolved);
+  if (!fs.existsSync(absolutePath)) {
+    throw new ConfigError(`Config file not found: ${resolved}`);
+  }
+  return absolutePath;
+}
+function parseTomlFile(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    return TOML.parse(content);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    throw new ConfigError(`Failed to parse ${CONFIG_FILE_NAME}: ${message}`);
+  }
+}
+function validateConfig(rawConfig) {
+  const result = configSchema.safeParse(rawConfig);
+  if (!result.success) {
+    const errors = result.error.errors.map((e) => `  - ${e.path.join(".")}: ${e.message}`).join("\n");
+    throw new ConfigError(`Invalid ${CONFIG_FILE_NAME} configuration:
+${errors}`);
+  }
+  return result.data;
+}
+function loadConfig(configPath) {
+  const resolvedPath = resolveConfigPath(configPath);
+  const rawConfig = parseTomlFile(resolvedPath);
+  const validatedConfig = validateConfig(rawConfig);
+  const config = mergeWithDefaults(validatedConfig);
+  return { config, configPath: resolvedPath };
+}
+async function loadConfigAsync(configPath) {
+  const resolvedPath = resolveConfigPath(configPath);
+  const rawConfig = parseTomlFile(resolvedPath);
+  const validatedConfig = validateConfig(rawConfig);
+  const configDir = path.dirname(resolvedPath);
+  const resolvedConfig = await resolveExtends(validatedConfig, configDir);
+  const config = mergeWithDefaults(resolvedConfig);
+  return { config, configPath: resolvedPath };
+}
+function merge(a, b) {
+  return { ...a, ...b };
+}
+function mergeLinting(c, dc) {
+  const cl = c.code?.linting;
+  const dl = dc.code?.linting;
+  return { eslint: merge(dl?.eslint, cl?.eslint), ruff: merge(dl?.ruff, cl?.ruff) };
+}
+function mergeSecurity(c, dc) {
+  const cs = c.code?.security;
+  const ds = dc.code?.security;
+  return {
+    secrets: merge(ds?.secrets, cs?.secrets),
+    pnpmaudit: merge(ds?.pnpmaudit, cs?.pnpmaudit),
+    pipaudit: merge(ds?.pipaudit, cs?.pipaudit)
+  };
+}
+function mergeTypes(c, dc) {
+  return {
+    tsc: merge(dc.code?.types?.tsc, c.code?.types?.tsc),
+    ty: merge(dc.code?.types?.ty, c.code?.types?.ty)
+  };
+}
+function mergeUnused(c, dc) {
+  return {
+    knip: merge(dc.code?.unused?.knip, c.code?.unused?.knip),
+    vulture: merge(dc.code?.unused?.vulture, c.code?.unused?.vulture)
+  };
+}
+function mergeCoverageRun(c, dc) {
+  return merge(dc.code?.coverage_run, c.code?.coverage_run);
+}
+function mergeNaming(c, dc) {
+  const cn = c.code?.naming;
+  const dn = dc.code?.naming;
+  return {
+    enabled: cn?.enabled ?? dn?.enabled ?? false,
+    rules: cn?.rules ?? dn?.rules
+  };
+}
+function mergeQuality(c, dc) {
+  const cq = c.code?.quality;
+  const dq = dc.code?.quality;
+  return {
+    "disable-comments": merge(dq?.["disable-comments"], cq?.["disable-comments"])
+  };
+}
+function mergeCode(c, dc) {
+  return {
+    linting: mergeLinting(c, dc),
+    types: mergeTypes(c, dc),
+    unused: mergeUnused(c, dc),
+    coverage_run: mergeCoverageRun(c, dc),
+    security: mergeSecurity(c, dc),
+    naming: mergeNaming(c, dc),
+    quality: mergeQuality(c, dc)
+  };
+}
+var defaultHooks = { enabled: false, require_husky: true };
+var defaultCi = { enabled: false };
+var defaultBranches = { enabled: false, require_issue: false };
+var defaultCommits = { enabled: false, require_scope: false };
+var defaultChangesets = {
+  enabled: false,
+  validate_format: true,
+  require_description: true
+};
+var defaultPr = { enabled: false, require_issue: false };
+var defaultTickets = {
+  enabled: false,
+  require_in_commits: true,
+  require_in_branch: false
+};
+var defaultCoverage = { enabled: false, enforce_in: "config" };
+var defaultRepo = {
+  enabled: false,
+  require_branch_protection: false,
+  require_codeowners: false
+};
+var defaultBackups = { enabled: false, max_age_hours: 24 };
+var defaultCodeowners = { enabled: false };
+var defaultDocs = {
+  enabled: false,
+  path: "docs/",
+  enforcement: "warn",
+  staleness_days: 30
+};
+var defaultForbiddenFiles = { enabled: false };
+function mergeProcessSection(defaultVal, dcVal, cVal) {
+  return { ...defaultVal, ...dcVal, ...cVal };
+}
+function mergeProcessHooks(cp, dcp) {
+  return mergeProcessSection(defaultHooks, dcp?.hooks, cp?.hooks);
+}
+function mergeProcessCi(cp, dcp) {
+  return mergeProcessSection(defaultCi, dcp?.ci, cp?.ci);
+}
+function mergeProcessBranches(cp, dcp) {
+  return mergeProcessSection(defaultBranches, dcp?.branches, cp?.branches);
+}
+function mergeProcessCommits(cp, dcp) {
+  return mergeProcessSection(defaultCommits, dcp?.commits, cp?.commits);
+}
+function mergeProcessChangesets(cp, dcp) {
+  return mergeProcessSection(defaultChangesets, dcp?.changesets, cp?.changesets);
+}
+function mergeProcessPr(cp, dcp) {
+  return mergeProcessSection(defaultPr, dcp?.pr, cp?.pr);
+}
+function mergeProcessTickets(cp, dcp) {
+  return mergeProcessSection(defaultTickets, dcp?.tickets, cp?.tickets);
+}
+function mergeProcessCoverage(cp, dcp) {
+  return mergeProcessSection(defaultCoverage, dcp?.coverage, cp?.coverage);
+}
+function mergeProcessRepo(cp, dcp) {
+  return mergeProcessSection(defaultRepo, dcp?.repo, cp?.repo);
+}
+function mergeProcessBackups(cp, dcp) {
+  return mergeProcessSection(defaultBackups, dcp?.backups, cp?.backups);
+}
+function mergeProcessCodeowners(cp, dcp) {
+  const cco = cp?.codeowners;
+  const dco = dcp?.codeowners;
+  const registryRules = dco?.rules ?? [];
+  const projectRules = cco?.rules ?? [];
+  const ruleMap = /* @__PURE__ */ new Map();
+  for (const rule of registryRules) {
+    ruleMap.set(rule.pattern, rule);
+  }
+  for (const rule of projectRules) {
+    ruleMap.set(rule.pattern, rule);
+  }
+  const mergedRules = Array.from(ruleMap.values());
+  return {
+    ...defaultCodeowners,
+    ...dco,
+    ...cco,
+    rules: mergedRules.length > 0 ? mergedRules : void 0
+  };
+}
+function mergeProcessDocs(cp, dcp) {
+  return mergeProcessSection(defaultDocs, dcp?.docs, cp?.docs);
+}
+function mergeProcessForbiddenFiles(cp, dcp) {
+  return mergeProcessSection(defaultForbiddenFiles, dcp?.forbidden_files, cp?.forbidden_files);
+}
+function mergeProcess(c, dc) {
+  return {
+    hooks: mergeProcessHooks(c.process, dc.process),
+    ci: mergeProcessCi(c.process, dc.process),
+    branches: mergeProcessBranches(c.process, dc.process),
+    commits: mergeProcessCommits(c.process, dc.process),
+    changesets: mergeProcessChangesets(c.process, dc.process),
+    pr: mergeProcessPr(c.process, dc.process),
+    tickets: mergeProcessTickets(c.process, dc.process),
+    coverage: mergeProcessCoverage(c.process, dc.process),
+    repo: mergeProcessRepo(c.process, dc.process),
+    backups: mergeProcessBackups(c.process, dc.process),
+    codeowners: mergeProcessCodeowners(c.process, dc.process),
+    docs: mergeProcessDocs(c.process, dc.process),
+    forbidden_files: mergeProcessForbiddenFiles(c.process, dc.process)
+  };
+}
+function mergeWithDefaults(config) {
+  return {
+    code: mergeCode(config, defaultConfig),
+    process: mergeProcess(config, defaultConfig),
+    infra: {
+      enabled: config.infra?.enabled ?? defaultConfig.infra?.enabled ?? false,
+      manifest: config.infra?.manifest ?? defaultConfig.infra?.manifest ?? "infra-manifest.json"
+    },
+    monorepo: config.monorepo
+  };
+}
+function getProjectRoot(configPath) {
+  return path.dirname(configPath);
+}
+function checkRuleOverride(projectRule, registryOwners) {
+  if (!registryOwners) {
+    return null;
+  }
+  const registryStr = registryOwners.join(" ");
+  const projectStr = projectRule.owners.join(" ");
+  if (registryStr === projectStr) {
+    return null;
+  }
+  return {
+    section: "process.codeowners.rules",
+    key: projectRule.pattern,
+    registryValue: registryStr,
+    projectValue: projectStr
+  };
+}
+function detectCodeownersOverrides(registryConfig, projectConfig) {
+  const registryRules = registryConfig?.process?.codeowners?.rules ?? [];
+  const projectRules = projectConfig?.process?.codeowners?.rules ?? [];
+  const registryMap = new Map(registryRules.map((r) => [r.pattern, r.owners]));
+  return projectRules.map((rule) => checkRuleOverride(rule, registryMap.get(rule.pattern))).filter((o) => o !== null);
+}
+async function loadRegistryConfig(extendsConfig, configDir) {
+  const registryModule = await import("./registry-V65CC7IN.js");
+  const loc = registryModule.parseRegistryUrl(extendsConfig.registry, configDir);
+  const registryDir = await registryModule.fetchRegistry(loc);
+  let config = {};
+  for (const name of extendsConfig.rulesets) {
+    config = registryModule.mergeConfigs(config, registryModule.loadRuleset(registryDir, name));
+  }
+  return config;
+}
+async function loadConfigWithOverrides(configPath) {
+  const resolvedPath = resolveConfigPath(configPath);
+  const validatedConfig = validateConfig(parseTomlFile(resolvedPath));
+  let overrides = [];
+  if (validatedConfig.extends) {
+    const registryConfig = await loadRegistryConfig(
+      validatedConfig.extends,
+      path.dirname(resolvedPath)
+    );
+    overrides = detectCodeownersOverrides(registryConfig, validatedConfig);
+  }
+  const { config, configPath: finalPath } = await loadConfigAsync(configPath);
+  return { config, configPath: finalPath, overrides };
+}
+
+// ../core/src/registry.ts
+function detectAuthMethod() {
+  if (process.env.CONFORM_REGISTRY_TOKEN || process.env.GITHUB_TOKEN) {
+    return "token";
+  }
+  if (process.env.SSH_AUTH_SOCK) {
+    return "ssh";
+  }
+  return "none";
+}
+function getAuthToken() {
+  return process.env.CONFORM_REGISTRY_TOKEN ?? process.env.GITHUB_TOKEN;
+}
+function buildGitHubUrl(owner, repo, auth) {
+  switch (auth) {
+    case "ssh":
+      return `git@github.com:${owner}/${repo}.git`;
+    case "token": {
+      const token = getAuthToken();
+      if (token) {
+        return `https://x-access-token:${token}@github.com/${owner}/${repo}.git`;
+      }
+      return `https://github.com/${owner}/${repo}.git`;
+    }
+    case "none":
+    default:
+      return `https://github.com/${owner}/${repo}.git`;
+  }
+}
+function parseAuthFromUrl(url) {
+  if (url.startsWith("github+ssh:")) {
+    return { auth: "ssh", rest: url.slice(11) };
+  }
+  if (url.startsWith("github+token:")) {
+    return { auth: "token", rest: url.slice(13) };
+  }
+  if (url.startsWith("github:")) {
+    return { auth: "auto", rest: url.slice(7) };
+  }
+  throw new ConfigError(`Invalid GitHub registry URL: ${url}`);
+}
+function parseGitHubUrl(url) {
+  const { auth: explicitAuth, rest } = parseAuthFromUrl(url);
+  const [repoPath, ref] = rest.split("@");
+  const [owner, repo] = repoPath.split("/");
+  if (!owner || !repo) {
+    throw new ConfigError(
+      `Invalid GitHub registry URL: ${url}. Expected format: github:owner/repo or github+ssh:owner/repo`
+    );
+  }
+  const auth = explicitAuth === "auto" ? detectAuthMethod() : explicitAuth;
+  return {
+    type: "github",
+    owner,
+    repo,
+    ref: ref || void 0,
+    path: buildGitHubUrl(owner, repo, auth),
+    auth
+  };
+}
+function parseRegistryUrl(url, configDir) {
+  if (url.startsWith("github:") || url.startsWith("github+")) {
+    return parseGitHubUrl(url);
+  }
+  const localPath = !path2.isAbsolute(url) && configDir ? path2.resolve(configDir, url) : url;
+  return { type: "local", path: localPath };
+}
+async function updateExistingRepo(repoDir, ref) {
+  try {
+    if (ref) {
+      await execa("git", ["fetch", "--all"], { cwd: repoDir });
+      await execa("git", ["checkout", ref], { cwd: repoDir });
+    } else {
+      await execa("git", ["pull", "--ff-only"], { cwd: repoDir });
+    }
+    return true;
+  } catch {
+    fs2.rmSync(repoDir, { recursive: true, force: true });
+    return false;
+  }
+}
+async function cloneRepo(location, repoDir) {
+  const cacheDir = path2.dirname(repoDir);
+  fs2.mkdirSync(cacheDir, { recursive: true });
+  const cloneArgs = ["clone", "--depth", "1"];
+  if (location.ref) {
+    cloneArgs.push("--branch", location.ref);
+  }
+  cloneArgs.push(location.path, repoDir);
+  try {
+    await execa("git", cloneArgs, { timeout: 30 * 1e3 });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("timed out")) {
+      throw new ConfigError(`Registry clone timed out after 30 seconds: ${location.path}`);
+    }
+    throw new ConfigError(`Failed to clone registry: ${message}`);
+  }
+}
+async function fetchRegistry(location) {
+  if (location.type === "local") {
+    if (!fs2.existsSync(location.path)) {
+      throw new ConfigError(`Registry not found: ${location.path}`);
+    }
+    return location.path;
+  }
+  const cacheDir = path2.join(os.tmpdir(), "conform-registry-cache");
+  const repoDir = path2.join(cacheDir, `${location.owner}-${location.repo}`);
+  if (fs2.existsSync(repoDir)) {
+    await updateExistingRepo(repoDir, location.ref);
+  }
+  if (!fs2.existsSync(repoDir)) {
+    await cloneRepo(location, repoDir);
+  }
+  return repoDir;
+}
+function loadRuleset(registryDir, rulesetName) {
+  const rulesetPath = path2.join(registryDir, "rulesets", `${rulesetName}.toml`);
+  if (!fs2.existsSync(rulesetPath)) {
+    throw new ConfigError(`Ruleset not found: ${rulesetName} (expected at ${rulesetPath})`);
+  }
+  const content = fs2.readFileSync(rulesetPath, "utf-8");
+  let parsed;
+  try {
+    parsed = toml.parse(content);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new ConfigError(`Failed to parse ruleset ${rulesetName}: ${message}`);
+  }
+  const result = configSchema.safeParse(parsed);
+  if (!result.success) {
+    const errors = result.error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ");
+    throw new ConfigError(`Invalid ruleset ${rulesetName}: ${errors}`);
+  }
+  return result.data;
+}
+function mergeToolConfig(base, override) {
+  if (!override) {
+    return base;
+  }
+  return { ...base, ...override };
+}
+function mergeLinting2(base, override) {
+  if (!override) {
+    return base;
+  }
+  return {
+    ...base,
+    eslint: mergeToolConfig(base?.eslint, override.eslint),
+    ruff: mergeToolConfig(base?.ruff, override.ruff)
+  };
+}
+function mergeTypes2(base, override) {
+  if (!override) {
+    return base;
+  }
+  return {
+    ...base,
+    tsc: mergeToolConfig(base?.tsc, override.tsc),
+    ty: mergeToolConfig(base?.ty, override.ty)
+  };
+}
+function mergeUnused2(base, override) {
+  if (!override) {
+    return base;
+  }
+  return {
+    ...base,
+    knip: mergeToolConfig(base?.knip, override.knip),
+    vulture: mergeToolConfig(base?.vulture, override.vulture)
+  };
+}
+function mergeSecurity2(base, override) {
+  if (!override) {
+    return base;
+  }
+  return {
+    ...base,
+    secrets: mergeToolConfig(base?.secrets, override.secrets),
+    pnpmaudit: mergeToolConfig(base?.pnpmaudit, override.pnpmaudit),
+    pipaudit: mergeToolConfig(base?.pipaudit, override.pipaudit)
+  };
+}
+function mergeNaming2(base, override) {
+  if (!override) {
+    return base;
+  }
+  return {
+    enabled: override.enabled,
+    rules: override.rules ?? base?.rules
+  };
+}
+function mergeQuality2(base, override) {
+  if (!override) {
+    return base;
+  }
+  return {
+    ...base,
+    "disable-comments": mergeToolConfig(base?.["disable-comments"], override["disable-comments"])
+  };
+}
+function mergeCodeSection(base, override) {
+  return {
+    linting: mergeLinting2(base?.linting, override.linting),
+    types: mergeTypes2(base?.types, override.types),
+    unused: mergeUnused2(base?.unused, override.unused),
+    coverage_run: mergeToolConfig(base?.coverage_run, override.coverage_run),
+    security: mergeSecurity2(base?.security, override.security),
+    naming: mergeNaming2(base?.naming, override.naming),
+    quality: mergeQuality2(base?.quality, override.quality)
+  };
+}
+function mergeHooksConfig(base, override) {
+  if (!override) {
+    return base;
+  }
+  return {
+    enabled: override.enabled,
+    require_husky: override.require_husky,
+    require_hooks: override.require_hooks ?? base?.require_hooks,
+    commands: override.commands ?? base?.commands
+  };
+}
+function mergeCiConfig(base, override) {
+  if (!override) {
+    return base;
+  }
+  return {
+    enabled: override.enabled,
+    require_workflows: override.require_workflows ?? base?.require_workflows,
+    jobs: override.jobs ?? base?.jobs,
+    actions: override.actions ?? base?.actions
+  };
+}
+function mergeBranchesConfig(base, override) {
+  if (!override) {
+    return base;
+  }
+  return {
+    enabled: override.enabled,
+    require_issue: override.require_issue,
+    pattern: override.pattern ?? base?.pattern,
+    exclude: override.exclude ?? base?.exclude,
+    issue_pattern: override.issue_pattern ?? base?.issue_pattern
+  };
+}
+function mergePrConfig(base, override) {
+  if (!override) {
+    return base;
+  }
+  return {
+    enabled: override.enabled,
+    require_issue: override.require_issue,
+    max_files: override.max_files ?? base?.max_files,
+    max_lines: override.max_lines ?? base?.max_lines,
+    issue_keywords: override.issue_keywords ?? base?.issue_keywords
+  };
+}
+function mergeTicketsConfig(base, override) {
+  if (!override) {
+    return base;
+  }
+  return {
+    enabled: override.enabled,
+    pattern: override.pattern ?? base?.pattern,
+    require_in_commits: override.require_in_commits,
+    require_in_branch: override.require_in_branch
+  };
+}
+function mergeCoverageConfig(base, override) {
+  if (!override) {
+    return base;
+  }
+  return {
+    enabled: override.enabled,
+    min_threshold: override.min_threshold ?? base?.min_threshold,
+    enforce_in: override.enforce_in,
+    ci_workflow: override.ci_workflow ?? base?.ci_workflow,
+    ci_job: override.ci_job ?? base?.ci_job
+  };
+}
+function mergeCommitsConfig(base, override) {
+  if (!override) {
+    return base;
+  }
+  return {
+    enabled: override.enabled,
+    pattern: override.pattern ?? base?.pattern,
+    types: override.types ?? base?.types,
+    require_scope: override.require_scope,
+    max_subject_length: override.max_subject_length ?? base?.max_subject_length
+  };
+}
+function mergeChangesetsConfig(base, override) {
+  if (!override) {
+    return base;
+  }
+  return {
+    enabled: override.enabled,
+    require_for_paths: override.require_for_paths ?? base?.require_for_paths,
+    exclude_paths: override.exclude_paths ?? base?.exclude_paths,
+    validate_format: override.validate_format,
+    allowed_bump_types: override.allowed_bump_types ?? base?.allowed_bump_types,
+    require_description: override.require_description,
+    min_description_length: override.min_description_length ?? base?.min_description_length
+  };
+}
+function mergeRepoConfig(base, override) {
+  if (!override) {
+    return base;
+  }
+  return {
+    enabled: override.enabled,
+    require_branch_protection: override.require_branch_protection,
+    require_codeowners: override.require_codeowners,
+    ruleset: override.ruleset ?? base?.ruleset,
+    tag_protection: override.tag_protection ?? base?.tag_protection
+  };
+}
+function mergeBackupsConfig(base, override) {
+  if (!override) {
+    return base;
+  }
+  return {
+    enabled: override.enabled,
+    bucket: override.bucket ?? base?.bucket,
+    prefix: override.prefix ?? base?.prefix,
+    max_age_hours: override.max_age_hours,
+    region: override.region ?? base?.region
+  };
+}
+function mergeCodeownersConfig(base, override) {
+  if (!override) {
+    return base;
+  }
+  return {
+    enabled: override.enabled,
+    rules: override.rules ?? base?.rules
+  };
+}
+function mergeDocsConfig(base, override) {
+  if (!override) {
+    return base;
+  }
+  return {
+    enabled: override.enabled,
+    path: override.path,
+    enforcement: override.enforcement,
+    allowlist: override.allowlist ?? base?.allowlist,
+    max_files: override.max_files ?? base?.max_files,
+    max_file_lines: override.max_file_lines ?? base?.max_file_lines,
+    max_total_kb: override.max_total_kb ?? base?.max_total_kb,
+    staleness_days: override.staleness_days,
+    stale_mappings: override.stale_mappings ?? base?.stale_mappings,
+    min_coverage: override.min_coverage ?? base?.min_coverage,
+    coverage_paths: override.coverage_paths ?? base?.coverage_paths,
+    exclude_patterns: override.exclude_patterns ?? base?.exclude_patterns,
+    types: override.types ?? base?.types
+  };
+}
+function mergeProcessSection2(base, override) {
+  return {
+    hooks: mergeHooksConfig(base?.hooks, override.hooks),
+    ci: mergeCiConfig(base?.ci, override.ci),
+    branches: mergeBranchesConfig(base?.branches, override.branches),
+    commits: mergeCommitsConfig(base?.commits, override.commits),
+    changesets: mergeChangesetsConfig(base?.changesets, override.changesets),
+    pr: mergePrConfig(base?.pr, override.pr),
+    tickets: mergeTicketsConfig(base?.tickets, override.tickets),
+    coverage: mergeCoverageConfig(base?.coverage, override.coverage),
+    repo: mergeRepoConfig(base?.repo, override.repo),
+    backups: mergeBackupsConfig(base?.backups, override.backups),
+    codeowners: mergeCodeownersConfig(base?.codeowners, override.codeowners),
+    docs: mergeDocsConfig(base?.docs, override.docs)
+  };
+}
+function mergeConfigs(base, override) {
+  const merged = { ...base };
+  if (override.code) {
+    merged.code = mergeCodeSection(base.code, override.code);
+  }
+  if (override.process) {
+    merged.process = mergeProcessSection2(base.process, override.process);
+  }
+  if (override.infra) {
+    merged.infra = override.infra;
+  }
+  if (override.monorepo) {
+    merged.monorepo = override.monorepo;
+  }
+  return merged;
+}
+async function resolveExtends(config, configDir) {
+  if (!config.extends) {
+    return config;
+  }
+  const { registry, rulesets } = config.extends;
+  const location = parseRegistryUrl(registry, configDir);
+  const registryDir = await fetchRegistry(location);
+  let mergedConfig = {};
+  for (const rulesetName of rulesets) {
+    const ruleset = loadRuleset(registryDir, rulesetName);
+    mergedConfig = mergeConfigs(mergedConfig, ruleset);
+  }
+  const localConfig = {
+    code: config.code,
+    process: config.process,
+    infra: config.infra,
+    monorepo: config.monorepo
+  };
+  return mergeConfigs(mergedConfig, localConfig);
+}
+
+export {
+  DEFAULT_FORBIDDEN_FILES_IGNORE,
+  configSchema,
+  defaultConfig,
+  parseRegistryUrl,
+  fetchRegistry,
+  loadRuleset,
+  mergeConfigs,
+  resolveExtends,
+  CONFIG_FILE_NAME,
+  ConfigError,
+  findConfigFile,
+  loadConfig,
+  loadConfigAsync,
+  getProjectRoot,
+  loadConfigWithOverrides
+};
+//# sourceMappingURL=chunk-KHO6NIAI.js.map