@open-tomato/rafa 0.45.0 → 0.46.0

package/dist/index-gvek4r8m.js

@@ -0,0 +1,710 @@
+// @bun
+import {
+  BOARD_PROJECT_TEMPLATE_DEFAULT,
+  BOARD_RELATIONSHIP_MODES,
+  CLAUDE_SETTING_SOURCES,
+  CONFIG_VERSIONS,
+  DEFAULT_BRANCH_TEMPLATE,
+  INJECT_MODES,
+  OUTPUT_MODES,
+  STORE_BACKENDS,
+  SYNC_STRATEGIES,
+  below,
+  branchTemplate,
+  busyTimeoutMs,
+  claimsAhead,
+  claimsStaleAfter,
+  confidence,
+  dayCount,
+  describeValue,
+  directory,
+  duplicatesLevel,
+  flag,
+  githubLogin,
+  isMapping,
+  issueNumber,
+  lessonSwitch,
+  listOf,
+  mapReading,
+  messageOf,
+  oneOf,
+  projectNumber,
+  projectUrl,
+  recurrenceCount,
+  refused,
+  refusedWith,
+  routeTable,
+  skillResolverName,
+  subsetOf,
+  text,
+  tierPins,
+  tierSwitch,
+  trackerKind
+} from "./index-ykggr043.js";
+
+// packages/rafa/src/core/config/config-items.ts
+var itemText = text("a non-empty string");
+function readKeyedItem(shape, raw, at) {
+  const choices = shape.kinds.join(", ");
+  if (!isMapping(raw))
+    return refused(at, raw, `a mapping naming one of: ${choices}`);
+  const entries = Object.entries(raw);
+  const kinds = shape.kinds.filter((kind2) => entries.some(([name]) => name === kind2));
+  const [kind] = kinds;
+  if (kind === undefined)
+    return refusedWith([`${at.label} names none of: ${choices}`]);
+  if (kinds.length > 1) {
+    const named2 = kinds.join(" and ");
+    return refusedWith([`${at.label} names ${named2}, expected exactly one of: ${choices}`]);
+  }
+  const optionalKeys = shape.optionalFor(kind);
+  const problems = [];
+  const extras = [];
+  const optional = new Map;
+  let named;
+  for (const [name, value] of entries) {
+    if (name !== kind && !optionalKeys.includes(name)) {
+      extras.push({ key: `${at.key}.${name}`, value });
+      continue;
+    }
+    if (name !== kind && value === null)
+      continue;
+    const reading = itemText(value, below(at, `.${name}`));
+    problems.push(...reading.problems);
+    if (reading.value === undefined)
+      continue;
+    if (name === kind)
+      named = reading.value;
+    else
+      optional.set(name, reading.value);
+  }
+  return problems.length > 0 || named === undefined ? { value: undefined, problems, extras } : { value: { kind, named, optional }, problems, extras };
+}
+var PREREQUISITE_KINDS = ["tool", "env", "service", "lsp"];
+var REQUIRED_ITEM_KEYS = [...PREREQUISITE_KINDS, "probe"];
+var OPTIONAL_ITEM_KEYS = [...REQUIRED_ITEM_KEYS, "reason"];
+var requiredPrerequisite = (raw, at) => {
+  const shape = { kinds: PREREQUISITE_KINDS, optionalFor: () => ["probe"] };
+  return mapReading(readKeyedItem(shape, raw, at), (item) => Object.freeze({
+    kind: item.kind,
+    name: item.named,
+    probe: item.optional.get("probe") ?? null
+  }));
+};
+var optionalPrerequisite = (raw, at) => {
+  const shape = { kinds: PREREQUISITE_KINDS, optionalFor: () => ["probe", "reason"] };
+  return mapReading(readKeyedItem(shape, raw, at), (item) => Object.freeze({
+    kind: item.kind,
+    name: item.named,
+    probe: item.optional.get("probe") ?? null,
+    reason: item.optional.get("reason") ?? null
+  }));
+};
+var MODULE_SOURCE_KINDS = ["npm", "github", "path"];
+var MODULE_SOURCE_KEYS = [...MODULE_SOURCE_KINDS, "ref"];
+var moduleSource = (raw, at) => {
+  const shape = {
+    kinds: MODULE_SOURCE_KINDS,
+    optionalFor: (kind) => kind === "github" ? ["ref"] : []
+  };
+  return mapReading(readKeyedItem(shape, raw, at), (item) => Object.freeze({
+    kind: item.kind,
+    location: item.named,
+    ref: item.optional.get("ref") ?? null
+  }));
+};
+
+// packages/rafa/src/core/config/core-section.ts
+import { dirname, join } from "path";
+
+// packages/rafa/src/core/config/default-routing.ts
+var DEFAULT_ROUTES = Object.freeze([
+  Object.freeze(["prose", "doc-updater"]),
+  Object.freeze(["tests", "tdd-guide"]),
+  Object.freeze(["repair", "build-error-resolver"]),
+  Object.freeze(["review", "code-reviewer"]),
+  Object.freeze(["implementation", "loop-implementer"])
+]);
+var DEFAULT_ROUTING = new Map(DEFAULT_ROUTES);
+
+// packages/rafa/src/core/config/core-section.ts
+var CONFIG_FILE = join(".rafa", "config.yaml");
+var SCOPE_DIR = dirname(CONFIG_FILE);
+var CORE_PACKAGE = "core";
+var CORE_SPECS = {
+  version: { key: "version", read: oneOf(CONFIG_VERSIONS), cli: false },
+  store: { key: "store", read: oneOf(STORE_BACKENDS), cli: true },
+  effortBusyTimeoutMs: { key: "effort.busyTimeoutMs", read: busyTimeoutMs, cli: false },
+  effortSync: { key: "effort.sync", read: oneOf(SYNC_STRATEGIES), cli: false },
+  inject: { key: "plan.inject", read: oneOf(INJECT_MODES), cli: true },
+  planDir: { key: "plan.dir", read: directory, cli: true },
+  specsDir: { key: "specs.dir", read: directory, cli: true },
+  trackerDefault: { key: "tracker.default", read: trackerKind, cli: true },
+  trackerFallback: {
+    key: "tracker.fallback",
+    read: listOf(trackerKind, "tracker kind names"),
+    cli: false
+  },
+  learningAdapter: {
+    key: "learning.adapter",
+    read: text("a learning adapter name"),
+    cli: true
+  },
+  learningBlessMinConfidence: { key: "learning.bless.minConfidence", read: confidence, cli: false },
+  learningPromoteAfter: { key: "learning.promote.after", read: recurrenceCount, cli: false },
+  learningPromoteMinConfidence: { key: "learning.promote.minConfidence", read: confidence, cli: false },
+  outputMode: { key: "output.mode", read: oneOf(OUTPUT_MODES), cli: true },
+  prerequisitesRequired: {
+    key: "prerequisites.required",
+    read: listOf(requiredPrerequisite, "prerequisite items"),
+    cli: false,
+    itemKeys: REQUIRED_ITEM_KEYS
+  },
+  prerequisitesOptional: {
+    key: "prerequisites.optional",
+    read: listOf(optionalPrerequisite, "prerequisite items"),
+    cli: false,
+    itemKeys: OPTIONAL_ITEM_KEYS
+  },
+  trackingSpecs: { key: "tracking.specs", read: flag, cli: false },
+  trackingPlans: { key: "tracking.plans", read: flag, cli: false },
+  trackingAll: { key: "tracking.all", read: flag, cli: false },
+  modules: {
+    key: "modules",
+    read: listOf(moduleSource, "module sources"),
+    cli: false,
+    itemKeys: MODULE_SOURCE_KEYS
+  },
+  allowList: {
+    key: "allowList",
+    read: listOf(text("a module name"), "module names"),
+    cli: false
+  },
+  settingSources: {
+    key: "loop.settingSources",
+    read: subsetOf(CLAUDE_SETTING_SOURCES),
+    cli: true
+  },
+  loopWorktreeDir: { key: "loop.worktreeDir", read: directory, cli: false },
+  boardTrustedAuthors: {
+    key: "board.trustedAuthors",
+    read: listOf(githubLogin, "GitHub logins"),
+    cli: false
+  },
+  boardRelationships: {
+    key: "board.relationships",
+    read: oneOf(BOARD_RELATIONSHIP_MODES),
+    cli: false
+  },
+  boardProjectTemplate: { key: "board.project.template", read: projectUrl, cli: false },
+  boardProjectNumber: { key: "board.project.number", read: projectNumber, cli: false },
+  roadmapIssue: { key: "roadmap.issue", read: issueNumber, cli: false },
+  claimsStaleAfter: { key: "claims.staleAfter", read: claimsStaleAfter, cli: false },
+  claimsAhead: { key: "claims.ahead", read: claimsAhead, cli: false },
+  cleanupStaleDays: { key: "cleanup.staleDays", read: dayCount, cli: false },
+  cleanupWorktreeIdleDays: {
+    key: "cleanup.worktreeIdleDays",
+    read: dayCount,
+    cli: false
+  },
+  cleanupKeep: {
+    key: "cleanup.keep",
+    read: listOf(text("a glob pattern"), "glob patterns"),
+    cli: false
+  },
+  dangerousAcceptStaleRefs: {
+    key: "dangerous.acceptStaleRefs",
+    read: flag,
+    cli: false
+  },
+  dangerousSelfUpdateDuringLoop: {
+    key: "dangerous.selfUpdateDuringLoop",
+    read: flag,
+    cli: false
+  },
+  statusNotice: { key: "status.notice", read: flag, cli: false },
+  tiersRafa: { key: "tiers.rafa", read: tierSwitch, cli: false },
+  tiersSkills: { key: "tiers.skills", read: tierPins, cli: false, map: true },
+  tiersAgents: { key: "tiers.agents", read: tierPins, cli: false, map: true },
+  routing: { key: "routing", read: routeTable, cli: false, map: true },
+  taskSkills: { key: "task.skills", read: skillResolverName, cli: true },
+  taskLessons: { key: "task.lessons", read: lessonSwitch, cli: false },
+  mergeDuplicates: { key: "merge.duplicates", read: duplicatesLevel, cli: false },
+  namingBranch: { key: "naming.branch", read: branchTemplate, cli: false }
+};
+var CORE_DEFAULTS = Object.freeze({
+  version: 1,
+  store: "sqlite",
+  effortBusyTimeoutMs: 5000,
+  effortSync: "local",
+  inject: "stage",
+  planDir: join(".rafa", "plans"),
+  specsDir: join(".rafa", "specs"),
+  trackerDefault: "github",
+  trackerFallback: Object.freeze(["local"]),
+  learningAdapter: "local",
+  learningBlessMinConfidence: 0.5,
+  learningPromoteAfter: 3,
+  learningPromoteMinConfidence: 0.7,
+  outputMode: "text",
+  prerequisitesRequired: Object.freeze([]),
+  prerequisitesOptional: Object.freeze([]),
+  trackingSpecs: false,
+  trackingPlans: false,
+  trackingAll: false,
+  modules: Object.freeze([]),
+  allowList: Object.freeze([]),
+  settingSources: Object.freeze(["project", "local"]),
+  loopWorktreeDir: join(".rafa", "worktrees"),
+  boardTrustedAuthors: Object.freeze([]),
+  boardRelationships: "labels",
+  boardProjectTemplate: BOARD_PROJECT_TEMPLATE_DEFAULT,
+  boardProjectNumber: null,
+  roadmapIssue: null,
+  claimsStaleAfter: "3d",
+  claimsAhead: "off",
+  cleanupStaleDays: 30,
+  cleanupWorktreeIdleDays: 7,
+  cleanupKeep: Object.freeze([]),
+  dangerousAcceptStaleRefs: false,
+  dangerousSelfUpdateDuringLoop: false,
+  statusNotice: true,
+  tiersRafa: "on",
+  tiersSkills: new Map,
+  tiersAgents: new Map,
+  routing: DEFAULT_ROUTING,
+  taskSkills: "planner",
+  taskLessons: "on",
+  mergeDuplicates: "warn",
+  namingBranch: DEFAULT_BRANCH_TEMPLATE
+});
+var CORE_SECTION = Object.freeze({
+  package: CORE_PACKAGE,
+  settings: Object.freeze(CORE_SPECS),
+  defaults: CORE_DEFAULTS
+});
+
+// packages/rafa/src/core/config/config.ts
+import { join as join2 } from "path";
+
+// packages/rafa/src/core/config/config-origins.ts
+function originOf(source, setting, file, user) {
+  const layer = source === "file" ? file : source === "user" ? user : null;
+  if (layer === null)
+    return null;
+  return Object.freeze({ file: layer.path, entry: layer.entries?.get(setting) ?? 0 });
+}
+
+// packages/rafa/src/core/config/section.ts
+class ConfigSectionError extends Error {
+  problems;
+  constructor(problems) {
+    super(`rafa config sections: ${problems.join("; ")}`);
+    this.name = "ConfigSectionError";
+    this.problems = problems;
+  }
+}
+var EMPTY_CONFIG_REGISTRY = Object.freeze({
+  sections: Object.freeze([]),
+  settings: Object.freeze({}),
+  defaults: Object.freeze({}),
+  checks: Object.freeze([])
+});
+var DANGEROUS_PREFIX = "dangerous.";
+function quoted(value) {
+  return JSON.stringify(value) ?? String(value);
+}
+function frozenCopy(section) {
+  return Object.freeze({
+    package: section.package,
+    settings: Object.freeze({ ...section.settings }),
+    defaults: Object.freeze({ ...section.defaults }),
+    checks: Object.freeze([...section.checks ?? []])
+  });
+}
+function recordOwners(owners, section) {
+  for (const [name, spec] of Object.entries(section.settings)) {
+    if (!owners.names.has(name))
+      owners.names.set(name, section.package);
+    const key = spec?.key;
+    if (key !== undefined && !owners.keys.has(key)) {
+      owners.keys.set(key, { package: section.package, name });
+    }
+  }
+}
+function keyCollisionOf(owner, key, name, section) {
+  if (owner.name !== name) {
+    return `file key ${key} is defined by package ${quoted(owner.package)} under setting ${owner.name}` + ` and again by package ${quoted(section.package)} under setting ${name}`;
+  }
+  if (key.startsWith(DANGEROUS_PREFIX)) {
+    return `${key} is defined by package ${quoted(owner.package)} and again by package ${quoted(section.package)};` + " a dangerous. key is a person's consent and one package defines it";
+  }
+  return null;
+}
+function collisionsOf(owners, section) {
+  return Object.entries(section.settings).flatMap(([name, spec]) => {
+    const problems = [];
+    const nameOwner = owners.names.get(name);
+    if (nameOwner !== undefined) {
+      problems.push(`setting ${name} is registered by package ${quoted(nameOwner)}` + ` and again by package ${quoted(section.package)}`);
+    }
+    const key = spec?.key;
+    const keyOwner = key === undefined ? undefined : owners.keys.get(key);
+    const keyProblem = key === undefined || keyOwner === undefined ? null : keyCollisionOf(keyOwner, key, name, section);
+    if (keyProblem !== null)
+      problems.push(keyProblem);
+    return problems;
+  });
+}
+function unpairedOf(sections) {
+  const specified = new Set(sections.flatMap((section) => Object.keys(section.settings)));
+  const defaulted = new Set(sections.flatMap((section) => Object.keys(section.defaults)));
+  return sections.flatMap((section) => [
+    ...Object.keys(section.defaults).filter((name) => !specified.has(name)).map((name) => `package ${quoted(section.package)} gives a default for ${name},` + " a RafaConfig field no section defines a setting for"),
+    ...Object.keys(section.settings).filter((name) => !defaulted.has(name)).map((name) => `package ${quoted(section.package)} defines setting ${name},` + " a RafaConfig field no section gives a default for")
+  ]);
+}
+function mergeConfigSections(registry, sections) {
+  const owners = { names: new Map, keys: new Map };
+  for (const section of registry.sections)
+    recordOwners(owners, section);
+  const problems = [];
+  const accepted = [];
+  for (const section of sections) {
+    if (typeof section.package !== "string" || section.package === "") {
+      problems.push(`a section's package is ${quoted(section.package)}; expected a non-empty package name`);
+    }
+    const copy = frozenCopy(section);
+    problems.push(...collisionsOf(owners, copy));
+    recordOwners(owners, copy);
+    accepted.push(copy);
+  }
+  const merged = [...registry.sections, ...accepted];
+  problems.push(...unpairedOf(merged));
+  if (problems.length > 0)
+    throw new ConfigSectionError(problems);
+  return Object.freeze({
+    sections: Object.freeze(merged),
+    settings: Object.freeze(merged.reduce((all, section) => ({ ...all, ...section.settings }), {})),
+    defaults: Object.freeze(merged.reduce((all, section) => ({ ...all, ...section.defaults }), {})),
+    checks: Object.freeze(merged.flatMap((section) => section.checks ?? []))
+  });
+}
+var active = EMPTY_CONFIG_REGISTRY;
+function registerConfigSections(sections) {
+  const previous = active;
+  active = mergeConfigSections(previous, sections);
+  return previous;
+}
+function activeSections() {
+  return active.sections;
+}
+function activeSettings() {
+  return active.settings;
+}
+function activeDefaults() {
+  return active.defaults;
+}
+function activeChecks() {
+  return active.checks;
+}
+function prefixesOf(key) {
+  const parts = key.split(".");
+  return parts.slice(1).map((_, index) => parts.slice(0, index + 1).join("."));
+}
+function keyIndexOf(registry) {
+  const settingByKey = new Map;
+  const knownUnder = new Map;
+  const add = (parent, name) => {
+    const names = knownUnder.get(parent) ?? [];
+    if (!names.includes(name))
+      knownUnder.set(parent, [...names, name]);
+  };
+  for (const [name, spec] of Object.entries(registry.settings)) {
+    if (spec === undefined)
+      continue;
+    settingByKey.set(spec.key, name);
+    const parts = spec.key.split(".");
+    parts.forEach((part, index) => add(parts.slice(0, index).join("."), part));
+    for (const item of spec.itemKeys ?? [])
+      add(`${spec.key}[]`, item);
+  }
+  const sectionPaths = new Set([...settingByKey.keys()].flatMap(prefixesOf));
+  return { settingByKey, sectionPaths, knownUnder };
+}
+var keyIndexes = new WeakMap;
+function activeKeyIndex() {
+  const cached = keyIndexes.get(active);
+  if (cached !== undefined)
+    return cached;
+  const built = keyIndexOf(active);
+  keyIndexes.set(active, built);
+  return built;
+}
+function activeSettingByKey() {
+  return activeKeyIndex().settingByKey;
+}
+function activeSectionPaths() {
+  return activeKeyIndex().sectionPaths;
+}
+function parentOf(key) {
+  const cut = key.lastIndexOf(".");
+  return cut < 0 ? "" : key.slice(0, cut);
+}
+var TRAILING_INDEX = /\[\d+\]$/;
+function activeKnownKeysAbove(key) {
+  const { knownUnder } = activeKeyIndex();
+  for (let parent = parentOf(key);parent !== ""; parent = parentOf(parent)) {
+    const names = knownUnder.get(parent.replace(TRAILING_INDEX, "[]"));
+    if (names !== undefined)
+      return [parent, names];
+  }
+  return ["", knownUnder.get("") ?? []];
+}
+var loadHook = null;
+function setConfigLoadHook(hook) {
+  const previous = loadHook;
+  loadHook = hook;
+  return previous;
+}
+function activeConfigLoadHook() {
+  return loadHook;
+}
+
+// packages/rafa/src/core/config/config.ts
+class ConfigError extends Error {
+  problems;
+  constructor(problems, options) {
+    super(`rafa config: ${problems.join("; ")}`, options);
+    this.name = "ConfigError";
+    this.problems = problems;
+  }
+}
+function registeredNames() {
+  return Object.keys(activeSettings());
+}
+function specOf(setting) {
+  const spec = activeSettings()[setting];
+  if (spec === undefined)
+    throw new Error(`rafa config: setting ${setting} is not registered`);
+  return spec;
+}
+function isCommandLineSetting(setting) {
+  return specOf(setting).cli;
+}
+function readLayer(rawOf, atOf) {
+  const problems = [];
+  const extras = [];
+  const entries = registeredNames().map((setting) => {
+    const raw = rawOf(setting);
+    if (raw === undefined)
+      return [setting, undefined];
+    const reading = specOf(setting).read(raw, atOf(setting));
+    problems.push(...reading.problems);
+    extras.push(...reading.extras);
+    return [setting, reading.value];
+  });
+  const layer = Object.fromEntries(entries);
+  return { layer, problems, extras };
+}
+function* entriesOf(mapping, prefix) {
+  const sectionPaths = activeSectionPaths();
+  for (const [name, value] of Object.entries(mapping)) {
+    const key = prefix === "" ? name : `${prefix}.${name}`;
+    if (sectionPaths.has(key) && isMapping(value))
+      yield* entriesOf(value, key);
+    else
+      yield { key, value };
+  }
+}
+function sortKeys(document, path) {
+  const named = new Map;
+  const seen = new Set;
+  const extras = [];
+  const problems = [];
+  const settingByKey = activeSettingByKey();
+  const sectionPaths = activeSectionPaths();
+  for (const entry of entriesOf(document, "")) {
+    const setting = settingByKey.get(entry.key);
+    if (setting !== undefined) {
+      if (seen.has(setting)) {
+        problems.push(`${path}: ${entry.key} is given more than once`);
+      } else if (entry.value !== null) {
+        named.set(setting, entry.value);
+      }
+      seen.add(setting);
+      continue;
+    }
+    if (!sectionPaths.has(entry.key)) {
+      extras.push(entry);
+      continue;
+    }
+    if (entry.value !== null) {
+      const found = describeValue(entry.value);
+      problems.push(`${path}: ${entry.key} must be a mapping, found ${found}`);
+    }
+  }
+  return { named, extras, problems };
+}
+var TAB_INDENTED_LINE = /^[ \t]*\t[ \t]*[^\s#]/;
+function tabIndentProblems(text2, path) {
+  return text2.split(/\r?\n/).flatMap((line, index) => TAB_INDENTED_LINE.test(line) ? [`${path}: line ${index + 1} is indented with a tab; YAML indents with spaces only`] : []);
+}
+function parseConfigDocument(text2, path) {
+  const tabProblems = tabIndentProblems(text2, path);
+  if (tabProblems.length > 0)
+    throw new ConfigError(tabProblems);
+  try {
+    return Bun.YAML.parse(text2);
+  } catch (error) {
+    const problem = `${path}: not valid YAML (${messageOf(error)})`;
+    throw new ConfigError([problem], { cause: error });
+  }
+}
+function configFilePath(root) {
+  return join2(root, CONFIG_FILE);
+}
+function parseConfigText(text2, path) {
+  return readConfigDocument(parseConfigDocument(text2, path), path);
+}
+function readConfigDocument(parsed, path) {
+  const document = parsed ?? {};
+  if (!isMapping(document)) {
+    const found = describeValue(document);
+    throw new ConfigError([
+      `${path}: expected a mapping at the top level, found ${found}`
+    ]);
+  }
+  const sorted = sortKeys(document, path);
+  const read = readLayer((setting) => sorted.named.get(setting), (setting) => ({
+    label: `${path}: ${specOf(setting).key}`,
+    key: specOf(setting).key
+  }));
+  const all = [...sorted.problems, ...read.problems];
+  if (all.length > 0)
+    throw new ConfigError(all);
+  return { path, values: read.layer, extras: [...sorted.extras, ...read.extras] };
+}
+function isMapSetting(setting) {
+  return specOf(setting).map === true;
+}
+function mergeMaps(...layers) {
+  const merged = new Map;
+  for (const layer of layers) {
+    if (!(layer instanceof Map))
+      continue;
+    for (const [name, value] of layer)
+      merged.set(name, value);
+  }
+  return merged;
+}
+function unloadedPinWarnings(layer) {
+  const pins = [
+    ["tiers.skills", layer.values.tiersSkills],
+    ["tiers.agents", layer.values.tiersAgents]
+  ];
+  return pins.flatMap(([key, map]) => [...map ?? []].filter(([, pin]) => pin === "rafa").map(([name]) => `rafa config: ${key}.${name} in ${layer.path} pins the rafa tier, ` + "which is not loaded (tiers.rafa is off), so the pin has no effect"));
+}
+function unknownKeyWarning(key, path) {
+  const quoted2 = JSON.stringify(key);
+  const [under, names] = activeKnownKeysAbove(key);
+  const where = under === "" ? "" : ` under ${under}`;
+  return `rafa config: unknown key ${quoted2} in ${path} has no effect ` + `in this version (known keys${where}: ${names.join(", ")})`;
+}
+function resolveConfig(layers = {}) {
+  const file = layers.file ?? null;
+  const user = layers.user ?? null;
+  const overrides = layers.cli ?? {};
+  const { layer: cli, problems } = readLayer((setting) => isCommandLineSetting(setting) ? overrides[setting] : undefined, (setting) => ({ label: `command line: ${setting}`, key: setting }));
+  if (problems.length > 0)
+    throw new ConfigError(problems);
+  const defaults = activeDefaults();
+  const rank = (setting) => {
+    const fromCli = cli[setting];
+    if (fromCli !== undefined)
+      return { value: fromCli, source: "cli" };
+    const fromFile = file?.values[setting];
+    const fromUser = user?.values[setting];
+    if (isMapSetting(setting)) {
+      const merged = mergeMaps(defaults[setting], fromUser, fromFile);
+      const source = fromFile !== undefined ? "file" : fromUser !== undefined ? "user" : "default";
+      return { value: merged, source };
+    }
+    if (fromFile !== undefined)
+      return { value: fromFile, source: "file" };
+    if (fromUser !== undefined)
+      return { value: fromUser, source: "user" };
+    return { value: defaults[setting], source: "default" };
+  };
+  const ranked = registeredNames().map((setting) => [setting, rank(setting)]);
+  const config = Object.fromEntries(ranked.map(([setting, { value }]) => [setting, value]));
+  const sources = Object.fromEntries(ranked.map(([setting, { source }]) => [setting, source]));
+  const provenance = Object.fromEntries(ranked.map(([setting, { source }]) => [setting, originOf(source, setting, file, user)]));
+  const path = file?.path ?? null;
+  const userPath = user?.path ?? null;
+  const checkProblems = activeChecks().flatMap((check) => check({ config, sources, path, userPath }));
+  if (checkProblems.length > 0)
+    throw new ConfigError(checkProblems);
+  const rafaLoaded = ranked.find(([setting]) => setting === "tiersRafa")?.[1].value !== "off";
+  const warnings = [user, file].flatMap((layer) => layer === null ? [] : [
+    ...layer.extras.map((extra) => unknownKeyWarning(extra.key, layer.path)),
+    ...rafaLoaded ? [] : unloadedPinWarnings(layer)
+  ]);
+  return {
+    config,
+    sources,
+    path,
+    userPath,
+    extras: file?.extras ?? [],
+    userExtras: user?.extras ?? [],
+    warnings,
+    provenance,
+    shadowed: []
+  };
+}
+
+// packages/rafa/src/core/config/scope.ts
+import { join as join3 } from "path";
+function scopeAt(base, file = configFilePath(base)) {
+  return { dir: join3(base, SCOPE_DIR), configFile: file };
+}
+// packages/rafa/src/core/config/dangerous.ts
+import { AsyncLocalStorage } from "async_hooks";
+var DANGEROUS_PREFIX2 = "dangerous.";
+var NO_PHRASES = Object.freeze({});
+var phraseScopes = new AsyncLocalStorage;
+var modulePhrases = NO_PHRASES;
+function dangerousPhrases() {
+  return phraseScopes.getStore() ?? modulePhrases;
+}
+var written = new WeakMap;
+function dangerousSettings() {
+  return Object.entries(activeSettings()).flatMap(([setting, spec]) => spec?.key.startsWith(DANGEROUS_PREFIX2) ? [{ setting, key: spec.key }] : []);
+}
+function sameValue(first, second) {
+  return Object.is(first, second) || JSON.stringify(first) === JSON.stringify(second);
+}
+function dangerousPassLines(resolved) {
+  const defaults = activeDefaults();
+  const phrases = dangerousPhrases();
+  return dangerousSettings().flatMap(({ setting, key }) => {
+    const value = resolved.config[setting];
+    if (sameValue(value, defaults[setting]))
+      return [];
+    const origin = resolved.provenance[setting] ?? null;
+    const where = origin === null ? "command line" : `${origin.file}, entry ${origin.entry}`;
+    const phrase = Object.hasOwn(phrases, key) ? `; ${phrases[key]}` : "";
+    return [`${key}: ${describeValue(value)} (${where})${phrase}`];
+  });
+}
+function writeDangerousPassLines(resolved, warn, invocation) {
+  const seen = written.get(invocation) ?? new Set;
+  written.set(invocation, seen);
+  for (const line of dangerousPassLines(resolved)) {
+    if (seen.has(line))
+      continue;
+    seen.add(line);
+    warn(line);
+  }
+}
+export { PREREQUISITE_KINDS, requiredPrerequisite, optionalPrerequisite, MODULE_SOURCE_KINDS, DEFAULT_ROUTING, CONFIG_FILE, SCOPE_DIR, CORE_SECTION, registerConfigSections, activeSections, activeSettings, activeDefaults, activeSettingByKey, setConfigLoadHook, activeConfigLoadHook, ConfigError, parseConfigDocument, configFilePath, parseConfigText, readConfigDocument, resolveConfig, writeDangerousPassLines, scopeAt };