@open-tomato/rafa 0.44.0 → 0.46.0

package/dist/config/entry.d.ts

@@ -0,0 +1,119 @@
+/**
+ * One config entry and the list of them a config module exports:
+ * {@link ConfigEntry}, rafa's own deep partial of the nested file shape
+ * `ConfigShape` (`shape.ts`), {@link Config}, {@link defineConfig}, and
+ * {@link entryOf}, which nests dotted keys into an entry.
+ *
+ * ## What an entry may hold
+ *
+ * An entry holds any part of the shape, every key at every depth
+ * optional, and two more forms the merge reads:
+ *
+ * - `false` at an id of a keyed map (`routing`, `tiers.skills`,
+ *   `tiers.agents`, `logger.modules`) overrides what an earlier entry
+ *   gave that id, so `{ logger: { modules: { board: false } } }` drops
+ *   what an earlier entry gave `board`. Where the map takes `false` as a
+ *   value (`routing`, the `tiers` pins) the loader keeps it as one, so it
+ *   also shadows a lower layer's row, as in a YAML file; where it does
+ *   not (`logger.modules`) the id is removed (`config-load.ts` in
+ *   `packages/rafa/src/core/config/`). A named key takes `false` only where its own
+ *   value does (`loop.retries`), never to remove it.
+ * - `{ $replace: true, …rest }` at any mapping below the top replaces
+ *   that mapping whole with `rest`, discarding what earlier entries put
+ *   there. On a scalar or a list it is a type error, since a later
+ *   entry's list replaces an earlier one whole already. Inside `rest`
+ *   neither form is read again: `rest` is a plain deep partial.
+ *
+ * These are the rules `@open-tomato/define-config`'s `merge` reads and
+ * its own `ConfigEntry` types. The type is declared here rather than
+ * imported so the `./config` subpath's declaration names nothing outside
+ * rafa. Its shapes follow that package's: one mapped type over every key
+ * with `$replace` beside them, never the named keys intersected with a
+ * keyed map's index signature, which that package's notes give as
+ * letting a stray `true` past at a map id.
+ *
+ * ## Values
+ *
+ * {@link defineConfig} is the identity: it answers the very list it is
+ * given and exists for its parameter type, so an editor flags a wrong
+ * key or value as the file is written. {@link entryOf} builds an entry
+ * from dotted keys, as `index.ts`'s `defaults` is built.
+ */
+import type { ConfigShape } from './shape.js';
+/** A value an entry never descends into: a scalar, or a list, which replaces whole. */
+type EntryLeaf = string | number | boolean | bigint | symbol | null | undefined | readonly unknown[];
+/** True when `K` is an index signature's key, an id of a keyed map, rather than a named key. */
+type IsMapId<K> = string extends K ? true : number extends K ? true : false;
+/** The value type of `T`'s string index signature, or `never` when it has none. */
+type MapValue<T> = string extends keyof T ? T extends {
+    readonly [id: string]: infer V;
+} ? V : never : never;
+/** Every key of `T`, optional, its index signature included: the skeleton the shapes below map over. */
+type Keys<T> = {
+    [K in keyof T]?: 0;
+};
+/** `T` with every key at every depth optional, leaves whole: what `rest` of a `$replace` holds. */
+type PartialOf<T> = T extends EntryLeaf ? T : T extends object ? {
+    [K in keyof T]?: PartialOf<T[K]>;
+} : T;
+/** Maps skeleton `S` to a replacing mapping: `$replace` itself, then a deep partial of each key. */
+type ReplaceShape<S, T> = {
+    [K in keyof S]: K extends '$replace' ? true : IsMapId<K> extends true ? PartialOf<MapValue<T>> | true | undefined : PartialOf<T[K & keyof T]>;
+};
+/**
+ * `{ $replace: true, …rest }` standing in for a mapping of type `T`;
+ * `never` for a leaf, so a `$replace` on a scalar or a list is refused.
+ * Over a keyed map the index signature admits `true` beside each id's
+ * value, since `$replace` is checked against it too.
+ */
+type Replace<T> = T extends EntryLeaf ? never : T extends object ? ReplaceShape<{
+    $replace: 0;
+} & Keys<T>, T> : never;
+/** What an entry may set at key `K` of a mapping of type `T`. */
+type EntryAt<T, K> = IsMapId<K> extends true ? EntryOf<MapValue<T>> | Replace<MapValue<T>> | false | undefined : EntryOf<T[K & keyof T]> | Replace<T[K & keyof T]>;
+/** Maps skeleton `S`, with its modifiers, to the values an entry sets. */
+type EntryShape<S, T> = {
+    [K in keyof S]: EntryAt<T, K>;
+};
+/**
+ * An entry for a value of type `T`: a leaf whole, a mapping key by key
+ * with `false` at a map id and `$replace` below it; see the module note.
+ *
+ * @typeParam T - The shape, or any part of it.
+ */
+export type EntryOf<T> = T extends EntryLeaf ? T : T extends object ? EntryShape<Keys<T>, T> : T;
+/** One config entry: a deep partial of {@link ConfigShape}; see the module note. */
+export type ConfigEntry = EntryOf<ConfigShape>;
+/** A config module's default export: its entries, applied in order over rafa's defaults. */
+export type Config = readonly ConfigEntry[];
+/**
+ * Declares a config's entries. At run time the identity: it answers the
+ * very list it is given, unchanged.
+ *
+ * @example
+ * ```ts
+ * export default defineConfig([{ naming: { branch: 'work/{stub}' } }]);
+ * ```
+ *
+ * @param entries - The entries, in the order they apply.
+ * @returns `entries`, the same list.
+ */
+export declare function defineConfig(entries: Config): Config;
+/**
+ * Nests dotted keys into one entry: `[['plan.inject', 'task']]` into
+ * `{ plan: { inject: 'task' } }`, every mapping frozen, keys in the
+ * order first named. The values are taken as given, already in the
+ * file's spelling. Throws on an empty key or segment, on a key given
+ * twice, and on a key that is both a value and a mapping (`a` beside
+ * `a.b`).
+ *
+ * The answer is typed {@link ConfigEntry} on the caller's word:
+ * nothing here checks a key against the shape. `index.ts`'s `defaults`
+ * is built from the registry's own keys, and `index.test.ts` reads each
+ * value back through its setting's reader.
+ *
+ * @param pairs - Each dotted key with its value.
+ * @returns A new frozen entry.
+ */
+export declare function entryOf(pairs: readonly (readonly [key: string, value: unknown])[]): ConfigEntry;
+export {};

package/dist/config/index.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The `./config` subpath, `@open-tomato/rafa/config`: what a
+ * `rafa.config.ts` or `rafa.config.mjs` imports to type its entries.
+ *
+ * - `Config`, the list of entries a config module exports, each a
+ *   `ConfigEntry`, rafa's deep partial of the nested file shape
+ *   `ConfigShape` (`entry.ts`, `shape.ts`).
+ * - `defineConfig`, the identity, typed for its parameter.
+ * - {@link defaults}, the one entry holding every setting's default.
+ *
+ * ## The defaults entry
+ *
+ * {@link defaults} is built from the registry (`src/config-registry.ts`):
+ * each setting's file key, nested, holding its value from
+ * `CONFIG_DEFAULTS` in the file's spelling ({@link fileValueOf}). A
+ * setting whose default is null (`pr.base`, `hub.url`) is left out: no
+ * reader accepts null, and an absent key is what null stands for.
+ * `index.test.ts` reads every value back through its setting's reader
+ * to the default it came from.
+ *
+ * Importing this module imports the registry, so the sections are
+ * registered with core as `src/rafa.ts` and `src/index.ts` register
+ * them. `ConfigShape` does not lean on that import for its keys:
+ * `shape.ts` composes it from each section's exported interface by
+ * `import type`, so the declaration emitted for `shape.ts` imports every
+ * section's emitted `.d.ts` and `ConfigShape` names every section's keys
+ * in the published declarations as in a program built from source
+ * (`shape.test.ts` reads `ConfigShape['hub']['url']` as `string` from
+ * declarations emitted over this file).
+ */
+import type { ConfigEntry } from './entry.js';
+export type { Config, ConfigEntry } from './entry.js';
+export type { ConfigShape } from './shape.js';
+export { defineConfig } from './entry.js';
+/** Every setting's default, as one entry; see the module note. */
+export declare const defaults: ConfigEntry;

package/dist/config/index.js

@@ -0,0 +1,51 @@
+// @bun
+import {
+  CONFIG_DEFAULTS,
+  SETTINGS,
+  SETTING_NAMES
+} from "../index-j4k2vdz3.js";
+import"../index-gvek4r8m.js";
+import"../index-ykggr043.js";
+import"../index-z1w83f81.js";
+
+// src/config/entry.ts
+function defineConfig(entries) {
+  return entries;
+}
+function nest(placed, above) {
+  const heads = [...new Set(placed.map(([[head]]) => head ?? ""))];
+  return Object.freeze(Object.fromEntries(heads.map((head) => {
+    const key = above === "" ? head : `${above}.${head}`;
+    const under = placed.filter(([[first]]) => first === head);
+    const [leaf, ...more] = under.filter(([path]) => path.length === 1);
+    if (leaf === undefined)
+      return [head, nest(under.map(([path, value]) => [path.slice(1), value]), key)];
+    if (more.length > 0 || under.length > 1)
+      throw new Error(`rafa config: ${key} is given twice, or as a value and a mapping`);
+    return [head, leaf[1]];
+  })));
+}
+function entryOf(pairs) {
+  const placed = pairs.map(([key, value]) => {
+    const path = key.split(".");
+    if (path.some((segment) => segment === ""))
+      throw new Error(`rafa config: ${JSON.stringify(key)} is no dotted key`);
+    return [path, value];
+  });
+  return nest(placed, "");
+}
+
+// src/config/index.ts
+var COMMA_SEPARATED = new Set(["settingSources"]);
+function fileValueOf(setting, value) {
+  if (value instanceof Map)
+    return Object.freeze(Object.fromEntries(value));
+  if (COMMA_SEPARATED.has(setting) && Array.isArray(value))
+    return value.join(",");
+  return value;
+}
+var defaults = entryOf(SETTING_NAMES.filter((setting) => CONFIG_DEFAULTS[setting] !== null).map((setting) => [SETTINGS[setting].key, fileValueOf(setting, CONFIG_DEFAULTS[setting])]));
+export {
+  defineConfig,
+  defaults
+};

package/dist/config/shape.d.ts

@@ -0,0 +1,232 @@
+/**
+ * The nested file shape: {@link ConfigShape}, every key a config file
+ * writes, nested as the file nests it (`plan: { inject: 'stage' }` for
+ * `plan.inject`), each leaf typed as the file spells it. It is the type a
+ * `rafa.config.ts` entry is a deep partial of (`entry.ts`), and the
+ * `./config` subpath (`index.ts`) publishes it.
+ *
+ * ## The file's spelling, not the resolved value
+ *
+ * A leaf holds what the setting's reader accepts, which is not always
+ * what `RafaConfig` resolves it to. A map (`routing`, `tiers.skills`,
+ * `tiers.agents`, `logger.modules`) is a plain object here and a
+ * `ReadonlyMap` there; `loop.settingSources` is the comma-separated
+ * string the file writes (`project,local`) and a list there; an item of
+ * `prerequisites.required` or `modules` names its kind by its key
+ * (`{ tool: 'bun' }`, `{ npm: 'rafa-board' }`) where the resolved item
+ * carries `kind` and `name`; and a setting whose default is null
+ * (`pr.base`, `hub.url`) takes no null, since no reader accepts one.
+ *
+ * ## Who declares what
+ *
+ * This module declares core's own top-level keys, the keys of
+ * `packages/rafa/src/core/config/core-section.ts`, and composes {@link ConfigShape}
+ * from them and the interface each of the thirteen section files
+ * (`src/config-schema-*.ts`) exports for the keys it writes: `HubShape`
+ * for `hub`, `ReleaseShape` for `pr` and `release`, and so on, each
+ * extended by {@link ConfigShape}. A namespace two packages share is a
+ * named interface here holding core's keys and extending the part each
+ * section exports as an interface of its own: {@link LoopShape} extends
+ * `LoopRetriesShape`, `LoopContinueShape` and `WrapUpShape`,
+ * {@link BoardProjectShape} extends `BoardProjectLimitsShape`, and
+ * {@link DangerousShape} extends `ReleaseDangerousShape`.
+ *
+ * The composition is written out, not merged into this file by a
+ * section's `declare module`, so the declaration emitted for this file
+ * imports each section's emitted declaration and a reader of the
+ * `./config` subpath's `.d.ts` files alone sees every key.
+ * `shape.test.ts` emits the declarations in memory over
+ * `src/config/index.ts` and reads `ConfigShape['hub']['url']` as
+ * `string` from them.
+ *
+ * `shape.test.ts` reads every leaf back as a setting's key and every
+ * setting's key as a leaf, so a key added to a section without its leaf
+ * here, or the other way round, fails there.
+ *
+ * Every type is `import type`, so this module loads nothing.
+ */
+import type { BoardProjectLimitsShape } from '../config-schema-board-project.js';
+import type { BugsShape } from '../config-schema-bugs.js';
+import type { ErrorsShape } from '../config-schema-errors.js';
+import type { FeaturesShape } from '../config-schema-features.js';
+import type { HubShape } from '../config-schema-hub.js';
+import type { IssuesShape } from '../config-schema-issues.js';
+import type { LoggerShape } from '../config-schema-logger.js';
+import type { LoopContinueShape } from '../config-schema-loop-continue.js';
+import type { LoopRetriesShape } from '../config-schema-loop-retries.js';
+import type { ReleaseDangerousShape, ReleaseShape } from '../config-schema-release.js';
+import type { TestsShape } from '../config-schema-tests.js';
+import type { TriageShape } from '../config-schema-triage.js';
+import type { WrapUpShape } from '../config-schema-wrap-up.js';
+import type { ModuleSourceKind, PrerequisiteKind } from '@open-tomato/rafa/core/config';
+import type { BoardRelationshipMode, ClaimsAhead, ClaimsStaleAfter, ConfigVersion, DuplicatesLevel, InjectMode, LessonSwitch, OutputMode, RouteTarget, SkillResolverName, StoreBackend, SyncStrategy, TierPin, TierSwitch } from '@open-tomato/rafa/core/config/sections';
+/**
+ * An item keyed by its kind: one of `K` as its key, naming the item.
+ * `KindKeyed<'tool' | 'env'>` is `{ tool: string } | { env: string }`.
+ */
+type KindKeyed<K extends string> = {
+    readonly [P in K]: {
+        readonly [Q in P]: string;
+    };
+}[K];
+/** One `prerequisites.required` item as a file writes it: `{ tool: 'bun', probe: 'bun --version' }`. */
+export type PrerequisiteFileItem = KindKeyed<PrerequisiteKind> & {
+    /** The command that proves the item; left out or null to check presence alone. */
+    readonly probe?: string | null;
+};
+/** One `prerequisites.optional` item as a file writes it: a required item's keys and `reason`. */
+export type OptionalPrerequisiteFileItem = PrerequisiteFileItem & {
+    /** Why the item helps, for the line naming it missing. */
+    readonly reason?: string | null;
+};
+/**
+ * One `modules` entry as a file writes it: `{ npm: 'rafa-board' }`,
+ * `{ path: '../board' }`, or `{ github: 'owner/repo', ref: 'v1' }`.
+ */
+export type ModuleFileItem = KindKeyed<Exclude<ModuleSourceKind, 'github'>> | {
+    /** The `owner/repo` the module is cloned from. */
+    readonly github: string;
+    /** The git ref to check out; left out or null for the default branch. */
+    readonly ref?: string | null;
+};
+/**
+ * The `loop` namespace: core's two keys, and the keys the
+ * `loop-retries`, `loop-continue` and `wrap-up` sections write.
+ */
+export interface LoopShape extends LoopRetriesShape, LoopContinueShape, WrapUpShape {
+    /** `loop.settingSources`: a comma-separated subset of `user`, `project`, `local`. */
+    readonly settingSources: string;
+    /** `loop.worktreeDir`: where the loop's worktrees are made. */
+    readonly worktreeDir: string;
+}
+/** The `board.project` namespace: core's two keys and the `board-project` section's limits. */
+export interface BoardProjectShape extends BoardProjectLimitsShape {
+    /** `board.project.template`: the project board copied for a new board. */
+    readonly template: string;
+    /** `board.project.number`: the project board this repository's issues go on. */
+    readonly number: number;
+}
+/** The `board` namespace, core's, with the shared {@link BoardProjectShape} under `project`. */
+export interface BoardShape {
+    /** `board.trustedAuthors`: the GitHub logins whose board items are read without a prompt. */
+    readonly trustedAuthors: readonly string[];
+    /** `board.relationships`: how a parent and its children are linked. */
+    readonly relationships: BoardRelationshipMode;
+    /** The `board.project` keys. */
+    readonly project: BoardProjectShape;
+}
+/**
+ * The `dangerous` namespace: each key a person's consent to a step rafa
+ * otherwise refuses. Core's two, and the one the `release` section writes.
+ */
+export interface DangerousShape extends ReleaseDangerousShape {
+    /** `dangerous.acceptStaleRefs`. */
+    readonly acceptStaleRefs: boolean;
+    /** `dangerous.selfUpdateDuringLoop`. */
+    readonly selfUpdateDuringLoop: boolean;
+}
+/** The nested file shape: core's keys, and each section's; see the module note. */
+export interface ConfigShape extends BugsShape, ErrorsShape, FeaturesShape, HubShape, IssuesShape, LoggerShape, ReleaseShape, TestsShape, TriageShape {
+    /** `version`: the config format's version. */
+    readonly version: ConfigVersion;
+    /** `store`: the effort store's backend. */
+    readonly store: StoreBackend;
+    /** The `effort` keys. */
+    readonly effort: {
+        readonly busyTimeoutMs: number;
+        readonly sync: SyncStrategy;
+    };
+    /** The `plan` keys. */
+    readonly plan: {
+        readonly inject: InjectMode;
+        readonly dir: string;
+    };
+    /** The `specs` keys. */
+    readonly specs: {
+        readonly dir: string;
+    };
+    /** The `tracker` keys. */
+    readonly tracker: {
+        readonly default: string;
+        readonly fallback: readonly string[];
+    };
+    /** The `learning` keys. */
+    readonly learning: {
+        readonly adapter: string;
+        readonly bless: {
+            readonly minConfidence: number;
+        };
+        readonly promote: {
+            readonly after: number;
+            readonly minConfidence: number;
+        };
+    };
+    /** The `output` keys. */
+    readonly output: {
+        readonly mode: OutputMode;
+    };
+    /** The `prerequisites` keys. */
+    readonly prerequisites: {
+        readonly required: readonly PrerequisiteFileItem[];
+        readonly optional: readonly OptionalPrerequisiteFileItem[];
+    };
+    /** The `tracking` keys. */
+    readonly tracking: {
+        readonly specs: boolean;
+        readonly plans: boolean;
+        readonly all: boolean;
+    };
+    /** `modules`: where each module is installed from. */
+    readonly modules: readonly ModuleFileItem[];
+    /** `allowList`. */
+    readonly allowList: readonly string[];
+    /** The `loop` keys. */
+    readonly loop: LoopShape;
+    /** The `board` keys. */
+    readonly board: BoardShape;
+    /** The `roadmap` keys. */
+    readonly roadmap: {
+        readonly issue: number;
+    };
+    /** The `claims` keys. */
+    readonly claims: {
+        readonly staleAfter: ClaimsStaleAfter;
+        readonly ahead: ClaimsAhead;
+    };
+    /** The `cleanup` keys. */
+    readonly cleanup: {
+        readonly staleDays: number;
+        readonly worktreeIdleDays: number;
+        readonly keep: readonly string[];
+    };
+    /** The `dangerous` keys. */
+    readonly dangerous: DangerousShape;
+    /** The `status` keys. */
+    readonly status: {
+        readonly notice: boolean;
+    };
+    /** The `tiers` keys, each map a name to `false` or a tier. */
+    readonly tiers: {
+        readonly rafa: TierSwitch;
+        readonly skills: Readonly<Record<string, TierPin>>;
+        readonly agents: Readonly<Record<string, TierPin>>;
+    };
+    /** `routing`: a task shape to an agent, or `false`. */
+    readonly routing: Readonly<Record<string, RouteTarget>>;
+    /** The `task` keys. */
+    readonly task: {
+        readonly skills: SkillResolverName;
+        readonly lessons: LessonSwitch;
+    };
+    /** The `merge` keys. */
+    readonly merge: {
+        /** `merge.duplicates`: how two entries of one file setting one key are reported. */
+        readonly duplicates: DuplicatesLevel;
+    };
+    /** The `naming` keys. */
+    readonly naming: {
+        /** `naming.branch`: the template the branch `loop start` creates is named from, holding `{stub}` once. */
+        readonly branch: string;
+    };
+}
+export {};

package/dist/config-registry.d.ts

@@ -0,0 +1,127 @@
+/**
+ * The registry: the fourteen sections of the config schema, handed to
+ * core when {@link registerCoreConfigSections} is called, and the merged schema read off
+ * them, {@link SETTINGS}, {@link CONFIG_DEFAULTS}, {@link SETTING_NAMES},
+ * {@link SETTING_BY_KEY}, {@link SECTIONS} and {@link knownKeysAbove}.
+ *
+ * Core declares the section contract (`packages/rafa/src/core/config/section.ts`) and
+ * names no section. This module, outside `packages/rafa/src/core/`, is the one place
+ * the fourteen are listed, {@link CONFIG_SECTIONS}: core's own
+ * (`CORE_SECTION`) and the thirteen files `src/config-schema-*.ts` that
+ * each export one.
+ *
+ * Importing it registers nothing. {@link registerCoreConfigSections}
+ * calls `registerConfigSections` once, with that list cut into the runs
+ * {@link SETTINGS} holds (see the order below), so `activeSettings()`
+ * and `activeDefaults()` answer every setting; a registration core
+ * refuses throws from the call, naming what it refused. The root is
+ * called, never imported for its effect: under `"sideEffects": false`
+ * in a manifest, `bun build` drops an import kept for its effect alone.
+ * The root manifest declares no such field today, since bun 1.3.14's
+ * split build breaks under it (#1213).
+ * `src/rafa.ts` and `src/index.ts` call it as they load, after their
+ * imports, ahead of `registerCoreAdapters` and before anything that
+ * loads a config; core never imports this module. Until something calls
+ * it, `loadConfig` refuses, naming this module. `bun test` calls it once
+ * for the test process, from `src/tests/preload.ts`; a child process a
+ * test spawns runs no preload, and calls the root itself. A second call
+ * finds every setting registered already and registers nothing.
+ *
+ * The call also sets core's load hook (`setConfigLoadHook` in
+ * `packages/rafa/src/core/config/section.ts`) to {@link handConfigToLogger}, so every
+ * config `loadConfig` resolves hands the logger its `logger` settings
+ * without core importing the logger's section file.
+ *
+ * ## The order
+ *
+ * {@link SETTINGS} keeps the order the schema has always reported
+ * problems in, which is not the order of the list: core's settings are
+ * taken in runs, and each section's settings are spread whole between
+ * two of them, so `hub.url` follows `effort.sync` and the `board.project`
+ * limits follow `board.project.number`. The `release` section is spread
+ * in three parts, its `pr`, `release` and `dangerous.` keys, each where
+ * its keys have always stood.
+ *
+ * Core reads every setting in the order it was registered: a layer, a
+ * resolution, and the keys a warning about an unknown key lists. So the
+ * sections are registered cut into the runs {@link SETTINGS} holds them
+ * in (`inSettingOrder`), each cut under its section's package and a
+ * section's checks on its first cut, and core's registry holds every
+ * setting in this order. Registering the list whole would put core's
+ * forty-two first, and the warning recorded in
+ * `src/tests/fixtures/config-parity/` would list `hub` after `task`.
+ * `config-registry.test.ts` holds that the registry holds the same
+ * settings, in the same order, as the same specs, and the same defaults,
+ * as the same values.
+ *
+ * ## The closed set
+ *
+ * {@link SETTINGS} is a mapped record over `ConfigSetting` built from
+ * each section file's typed settings, so a field added to `RafaConfig`
+ * without a spec in some section does not compile. The indexes are all
+ * read off it. Keys are looked up in a `Map`, never with `in` or an
+ * object index: `Bun.YAML.parse` returns a key spelled `constructor` or
+ * `__proto__` as an ordinary own key, and an object lookup would match
+ * it against `Object.prototype` instead.
+ *
+ * ## Beside core
+ *
+ * This module is the one place the six names are built: the core barrel
+ * `packages/rafa/src/core/config/index.ts` exports none of them, and a file outside
+ * `packages/rafa/src/core/` imports them from here. Core reads the registered
+ * settings and defaults through `activeSettings()` and
+ * `activeDefaults()`, and the key indexes through `activeSettingByKey()`,
+ * `activeSectionPaths()` and `activeKnownKeysAbove()`, all in
+ * `packages/rafa/src/core/config/section.ts`. Those follow registration order, which
+ * is the order here, so they answer what {@link SETTING_BY_KEY},
+ * {@link SECTIONS} and {@link knownKeysAbove} answer.
+ * `src/index.ts` publishes this module's {@link CONFIG_DEFAULTS}.
+ */
+import type { ConfigSection, ConfigSetting, RafaConfig, SettingSpec } from '@open-tomato/rafa/core/config';
+/** The fourteen sections, core's first, in the order they are registered. */
+export declare const CONFIG_SECTIONS: readonly ConfigSection[];
+/**
+ * The hook `loadConfig` calls with every config it resolves: it hands
+ * the logger its `logger` settings, read through the logger section's
+ * `loggerSettingsOf`. Set by {@link registerCoreConfigSections}, beside
+ * the registration.
+ */
+export declare function handConfigToLogger(config: Readonly<RafaConfig>): void;
+/** What every setting resolves to when no layer names it. */
+export declare const CONFIG_DEFAULTS: Readonly<RafaConfig>;
+/**
+ * Every setting, by name, in the order problems are reported.
+ *
+ * A mapped record rather than a list so the set is closed: a field
+ * added to `RafaConfig` without an entry here does not compile.
+ */
+export declare const SETTINGS: {
+    readonly [K in ConfigSetting]: SettingSpec<K>;
+};
+/** Every setting name, read off the closed record above. */
+export declare const SETTING_NAMES: readonly ConfigSetting[];
+/**
+ * Registers {@link CONFIG_SECTIONS} with core, cut into the runs
+ * {@link SETTINGS} holds them in, and sets core's load hook to
+ * {@link handConfigToLogger}.
+ *
+ * When core's registry holds every setting already, each as the same
+ * spec, it registers nothing and leaves the load hook as it is, so the
+ * preload and an entry may both call it in one process. Throws what
+ * `registerConfigSections` throws on a section core refuses, such as a
+ * setting another package registered first, leaving the registry and
+ * the load hook as they were.
+ */
+export declare function registerCoreConfigSections(): void;
+/** Setting names by the dotted key the file spells them with. */
+export declare const SETTING_BY_KEY: ReadonlyMap<string, ConfigSetting>;
+/** Every dotted prefix a setting sits under: the sections a file opens. */
+export declare const SECTIONS: ReadonlySet<string>;
+/**
+ * The nearest path above `key` with known keys, and those keys. An
+ * item path such as `modules[0]` looks up `modules[]`.
+ *
+ * @param key - A dotted key a file spelled, `modules[0].kind` included.
+ * @returns The path the keys sit under, `''` for the top, and the keys.
+ */
+export declare function knownKeysAbove(key: string): [string, readonly string[]];