@@ -4895,6 +4895,100 @@ pub const fn concat_bindings<const N: usize>(
     joined
 }
 
+/// What a flag says about the setting it sets, so the flag can be the setting's declaration.
+///
+/// The type and the environment names a registry needs are already on the field that parses the
+/// flag, and writing them a second time on a `usage::Config` field is a second description to
+/// drift. So every command describes its bound settings in these terms, and the root — the one
+/// place that knows what a registry is — turns the joined table into `usage_config::PropMeta`.
+/// Like [`SettingGiven`], it names nothing from the config crate, so a group of flags declared in a
+/// library still never depends on it.
+///
+/// No flags here: the root reads those from the binding table, which already lists every spelling
+/// that sets each key, so the registry's `cli` and `SETTINGS_BINDINGS` cannot disagree.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct SettingDecl {
+    /// The dotted key, from `setting = "..."`.
+    pub key: &'static str,
+    /// What one value is.
+    pub ty: SettingTy,
+    /// Whether the field collects several values, making the setting a list of `ty`.
+    pub list: bool,
+    /// Environment variables that set it, highest precedence first.
+    pub envs: &'static [&'static str],
+    /// Deprecated environment aliases, consulted after every current name.
+    pub deprecated_envs: &'static [&'static str],
+    /// How one string becomes a list, from the field's `delimiter`.
+    pub split: Option<SettingSplit>,
+    pub help: Option<&'static str>,
+    pub long_help: Option<&'static str>,
+}
+
+impl SettingDecl {
+    /// A declaration with nothing but a key and a type.
+    pub const fn new(key: &'static str, ty: SettingTy) -> Self {
+        Self {
+            key,
+            ty,
+            list: false,
+            envs: &[],
+            deprecated_envs: &[],
+            split: None,
+            help: None,
+            long_help: None,
+        }
+    }
+}
+
+/// The type of one value of a flag-declared setting, read from the field.
+///
+/// A field whose type is not one of these — an enum, or anything else parsed with `FromStr` — is
+/// a `String` to the registry, which is what the flag hands it anyway.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum SettingTy {
+    Bool,
+    Int,
+    Uint,
+    Float,
+    String,
+    Path,
+}
+
+/// How a flag-declared list setting splits one string, from the field's `delimiter`.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum SettingSplit {
+    /// `delimiter = ','`.
+    Comma,
+    /// `delimiter = ':'`.
+    Colon,
+    /// Any other delimiter, which no registry parser splits on. The root refuses it unless a
+    /// `usage::Config` field declares the setting, so the environment never splits differently
+    /// from the flag.
+    Other,
+}
+
+/// The setting declarations of several commands, joined into one array.
+///
+/// The [`concat_bindings`] counterpart. A key may appear more than once — two subcommands can each
+/// have a `--jobs` that sets `jobs` — and the root folds those into one setting.
+pub const fn concat_setting_decls<const N: usize>(
+    parts: &[&'static [SettingDecl]],
+) -> [SettingDecl; N] {
+    let mut joined = [SettingDecl::new("", SettingTy::String); N];
+    let mut at = 0;
+    let mut part = 0;
+    while part < parts.len() {
+        let mut i = 0;
+        while i < parts[part].len() {
+            joined[at] = parts[part][i];
+            at += 1;
+            i += 1;
+        }
+        part += 1;
+    }
+    joined
+}
+
 /// Presence information exposed across a flattened [`CommandArgs`] boundary.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct ArgumentState {
@@ -5023,6 +5117,11 @@ pub trait CommandArgs: Sized {
     /// what `usage_config::Registry::drift` is held against.
     const SETTINGS_BINDINGS: &'static [(&'static str, &'static str)] = &[];
 
+    /// What this command's bound flags say about the settings they set.
+    ///
+    /// Empty by default, for the same reason as [`CommandArgs::SETTINGS_BINDINGS`].
+    const SETTING_DECLS: &'static [SettingDecl] = &[];
+
     /// The settings this command line gave values for.
     ///
     /// From the partial rather than from the built struct, and only for flags that were actually
@@ -5467,6 +5566,9 @@ pub trait Subcommands: Sized {
     /// is compared against a spec that documents all of them.
     const SETTINGS_BINDINGS: &'static [(&'static str, &'static str)] = &[];
 
+    /// What every one of these commands' bound flags says about the settings they set.
+    const SETTING_DECLS: &'static [SettingDecl] = &[];
+
     /// The settings the selected command was given values for, and no other command's.
     ///
     /// `None` selected is nothing given, which is also what a CLI that reached no subcommand
 
@@ -0,0 +1,207 @@
+//! A flag with `setting = "key"` as the declaration of that setting.
+//!
+//! Everything a registry entry says about a flag-backed setting is already on the field that parses
+//! the flag: the key, the type, the environment names, the help, and the flags themselves. So the
+//! root joins what its flags declare into `SETTINGS_REGISTRY`, and a `usage::Config` struct is left
+//! for the settings no flag sets — files only, or ones that need a default, a merge or a scope.
+//! A key both declare is the `Config` struct's.
+
+use std::ffi::OsStr;
+use std::path::PathBuf;
+
+use usage_config::{EnvLayer, Layers, Parser, Ty, Value, resolve};
+use usage_derive::{Args, Cli, Config, Subcommands};
+
+/// How the relay listens for TLS
+#[derive(Args, Debug)]
+struct ListenTls {
+    /// Load the given certificate from disk.
+    #[usage(
+        long = "listen-tls-cert",
+        env = "EX_LISTEN_TLS_CERT",
+        deprecated_env = "EX_TLS_CERT",
+        delimiter = ',',
+        setting = "listen.tls.cert"
+    )]
+    cert: Vec<PathBuf>,
+}
+
+/// Run the relay
+#[derive(Args, Debug)]
+struct Serve {
+    /// How many jobs to run at once
+    #[usage(long, short = 'j', setting = "jobs")]
+    jobs: Option<u16>,
+}
+
+/// Check the relay's configuration
+#[derive(Args, Debug)]
+struct Check {
+    /// How many jobs to run at once
+    #[usage(long, setting = "jobs")]
+    jobs: Option<u16>,
+}
+
+#[derive(Subcommands, Debug)]
+enum Cmd {
+    Serve(Serve),
+    Check(Check),
+}
+
+/// The settings no flag sets.
+#[derive(Config)]
+struct Settings {
+    /// Where the relay announces itself
+    #[usage(env = "EX_NAME")]
+    name: Option<String>,
+
+    /// Whether to colour the output
+    #[usage(default = true, cli("--colour", "--no-colour"))]
+    colour: bool,
+}
+
+/// A relay
+#[derive(Cli, Debug)]
+#[usage(bin = "ex", config = Settings)]
+struct Ex {
+    /// Whether to colour the output
+    #[usage(long, negate = "no-colour", setting = "colour")]
+    colour: bool,
+
+    /// How chatty to be
+    #[usage(short, count, setting = "log.verbose")]
+    verbose: u8,
+
+    #[usage(flatten)]
+    tls: ListenTls,
+
+    #[usage(subcommand)]
+    cmd: Cmd,
+}
+
+fn parse(tokens: &[&str]) -> (Ex, usage_config::CliLayer) {
+    let argv: Vec<&OsStr> = tokens.iter().map(OsStr::new).collect();
+    Ex::parse_from_with_settings(&argv).expect("should parse")
+}
+
+fn prop(key: &str) -> usage_config::PropMeta {
+    *Ex::SETTINGS_PROPS
+        .iter()
+        .find(|p| p.key == key)
+        .unwrap_or_else(|| panic!("`{key}` is declared"))
+}
+
+#[test]
+fn the_registry_declares_exactly_the_flags_the_cli_binds() {
+    // The adopter's drift test, with nothing hand-written on either side.
+    assert_eq!(
+        Ex::SETTINGS_REGISTRY.drift(Ex::SETTINGS_BINDINGS),
+        Vec::<String>::new()
+    );
+}
+
+#[test]
+fn a_flag_says_what_its_setting_is() {
+    let cert = prop("listen.tls.cert");
+    assert_eq!(cert.ty, Ty::List(&Ty::Path));
+    assert_eq!(cert.envs, ["EX_LISTEN_TLS_CERT"]);
+    assert_eq!(cert.deprecated_envs, ["EX_TLS_CERT"]);
+    assert_eq!(cert.parse, Some(Parser::ListByComma));
+    assert_eq!(cert.cli, ["--listen-tls-cert"]);
+    assert_eq!(cert.help, Some("Load the given certificate from disk."));
+    // No registry default, so absence is a state the reader handles.
+    assert_eq!(cert.optional, Some(true));
+
+    let verbose = prop("log.verbose");
+    assert_eq!(verbose.ty, Ty::Uint);
+    assert_eq!(verbose.cli, ["-v"]);
+}
+
+#[test]
+fn a_key_several_commands_bind_is_one_setting_with_all_their_flags() {
+    let jobs: Vec<_> = Ex::SETTINGS_PROPS
+        .iter()
+        .filter(|p| p.key == "jobs")
+        .collect();
+    assert_eq!(jobs.len(), 1);
+    assert_eq!(jobs[0].ty, Ty::Uint);
+    assert_eq!(jobs[0].cli, ["--jobs", "-j"]);
+}
+
+#[test]
+fn the_config_type_keeps_the_keys_it_declares_and_adds_the_rest() {
+    // `colour` is declared by both, and the `Config` struct's declaration — with its default —
+    // is the one the registry holds.
+    let colour = prop("colour");
+    assert_eq!(colour.default, Some(usage_config::Const::Bool(true)));
+    assert_eq!(
+        Ex::SETTINGS_PROPS
+            .iter()
+            .filter(|p| p.key == "colour")
+            .count(),
+        1
+    );
+    assert_eq!(prop("name").envs, ["EX_NAME"]);
+}
+
+#[test]
+fn the_flag_and_the_environment_reach_the_same_setting() {
+    let env = EnvLayer::new([("EX_LISTEN_TLS_CERT".to_string(), "a.pem,b.pem".to_string())]);
+    let (_, layer) = parse(&["serve"]);
+    let resolved =
+        resolve(Ex::SETTINGS_REGISTRY, Layers::new().then(&layer).then(&env)).expect("resolves");
+    assert_eq!(
+        resolved.get_key("listen.tls.cert"),
+        Some(&Value::List(vec![
+            Value::from("a.pem"),
+            Value::from("b.pem")
+        ]))
+    );
+
+    let (cli, layer) = parse(&["--listen-tls-cert", "c.pem", "check", "--jobs", "3"]);
+    assert_eq!(cli.tls.cert, [PathBuf::from("c.pem")]);
+    let resolved =
+        resolve(Ex::SETTINGS_REGISTRY, Layers::new().then(&layer).then(&env)).expect("resolves");
+    assert_eq!(
+        resolved.get_key("listen.tls.cert"),
+        Some(&Value::List(vec![Value::from("c.pem")]))
+    );
+    assert_eq!(resolved.get_key("jobs"), Some(&Value::Int(3)));
+}
+
+#[test]
+fn the_spec_documents_the_settings_the_flags_declare() {
+    let kdl = Ex::to_kdl();
+    assert!(kdl.contains(r#"prop "listen.tls.cert""#), "{kdl}");
+    assert!(kdl.contains(r#"prop "name""#), "{kdl}");
+    let _: usage::Spec = kdl.parse().expect("usage-lib reads the whole spec");
+}
+
+/// A tool whose only settings are the ones its flags declare
+#[derive(Cli, Debug)]
+#[usage(bin = "bare")]
+struct Bare {
+    /// How many jobs to run at once
+    #[usage(long, env = "BARE_JOBS", setting = "jobs")]
+    jobs: Option<u16>,
+}
+
+#[test]
+fn a_cli_with_no_config_type_still_documents_its_settings() {
+    let kdl = Bare::to_kdl();
+    assert!(kdl.contains(r#"prop "jobs""#), "{kdl}");
+    let _: usage::Spec = kdl.parse().expect("usage-lib reads the whole spec");
+}
+
+#[test]
+fn the_config_type_reads_its_own_settings_from_the_joined_registry() {
+    // The joined registry keeps the `Config` type's props first and in order, so its reader still
+    // finds them where it expects.
+    let env = EnvLayer::new([("EX_NAME".to_string(), "relay".to_string())]);
+    let (_, layer) = parse(&["--no-colour", "serve"]);
+    let resolved =
+        resolve(Ex::SETTINGS_REGISTRY, Layers::new().then(&layer).then(&env)).expect("resolves");
+    let settings = Settings::read(&resolved).expect("reads");
+    assert_eq!(settings.name.as_deref(), Some("relay"));
+    assert!(!settings.colour, "the flag outranks the default");
+}