@@ -762,19 +762,22 @@ std::expected<Manifest, ManifestError> parse_string(std::string_view content,
                 read_str_array(ft, "requires", reqs);
                 read_str_array(ft, "provides", provs);
                 if (!reqs.empty())  m.featureRequires[fname] = std::move(reqs);
-                // `requires_abi = { threads = true }`: this feature needs the
-                // artefact's ABI switch on. See Manifest::featureRequiresAbiThreads.
+                // `requires_abi = { threads = true, exceptions = true }`:
+                // this feature needs the artefact's ABI switch(es) on. See
+                // Manifest::featureRequiresAbiThreads /
+                // Manifest::featureRequiresAbiExceptions.
                 if (auto rait = ft.find("requires_abi"); rait != ft.end()) {
                     if (!rait->second.is_table())
                         return std::unexpected(error(origin, std::format(
                             "features.{}.requires_abi must be a table such as "
                             "`{{ threads = true }}`", fname)));
                     for (auto& [ak, av] : rait->second.as_table()) {
-                        if (ak != "threads" || !av.is_bool())
+                        if ((ak != "threads" && ak != "exceptions") || !av.is_bool())
                             return std::unexpected(error(origin, std::format(
                                 "features.{}.requires_abi.{}: the members are "
-                                "`threads`, a boolean", fname, ak)));
-                        m.featureRequiresAbiThreads[fname] = av.as_bool();
+                                "`threads`, `exceptions`, booleans", fname, ak)));
+                        if (ak == "threads") m.featureRequiresAbiThreads[fname] = av.as_bool();
+                        else m.featureRequiresAbiExceptions[fname] = av.as_bool();
                     }
                 }
                 if (!provs.empty()) m.featureProvides[fname] = std::move(provs);
@@ -945,16 +948,19 @@ std::expected<Manifest, ManifestError> parse_string(std::string_view content,
                 m.unknownCapabilities.push_back(entry);
         m.requires_ = *v;
     }
-    // [package] requires_abi -- see Manifest::requiresAbiThreads.
+    // [package] requires_abi -- see Manifest::requiresAbiThreads /
+    // Manifest::requiresAbiExceptions.
     if (auto* ra = doc->get("package.requires_abi")) {
         if (!ra->is_table())
             return std::unexpected(error(origin,
                 "[package] requires_abi must be a table such as `{ threads = true }`"));
         for (auto& [ak, av] : ra->as_table()) {
-            if (ak != "threads" || !av.is_bool())
+            if ((ak != "threads" && ak != "exceptions") || !av.is_bool())
                 return std::unexpected(error(origin, std::format(
-                    "[package] requires_abi.{}: the members are `threads`, a boolean", ak)));
-            m.requiresAbiThreads = av.as_bool();
+                    "[package] requires_abi.{}: the members are `threads`, "
+                    "`exceptions`, booleans", ak)));
+            if (ak == "threads") m.requiresAbiThreads = av.as_bool();
+            else m.requiresAbiExceptions = av.as_bool();
         }
     }
     // [package] exclusive — capabilities this package claims sole provision of.
@@ -2764,24 +2770,95 @@ std::expected<Manifest, ManifestError> parse_string(std::string_view content,
             // keys only, and the same two `[runtime]` already has at the top
             // level: this makes them per-target, it does not invent a vocabulary.
             // `[target.<pred>.abi]` -- graph-wide ABI switches as typed members
-            // rather than flags (design 2026-09-12, section 5.2). One member
-            // today, and an unknown member is refused, so the table cannot
-            // become a second flag list.
+            // rather than flags (design 2026-09-12, section 5.2; `exceptions`
+            // added by section 2.1, A1). Two members, and an unknown one is
+            // refused naming both, so the table cannot become a second flag
+            // list.
             if (auto ait = body.find("abi"); ait != body.end()) {
                 if (!ait->second.is_table())
                     return std::unexpected(error(origin, std::format(
                         "[target.{}].abi must be a table, e.g. `[target.{}.abi]` "
                         "with `threads = true`", triple, triple)));
                 for (auto& [ak, av] : ait->second.as_table()) {
-                    if (ak != "threads")
+                    if (ak != "threads" && ak != "exceptions")
                         return std::unexpected(error(origin, std::format(
                             "[target.{}.abi] has no member '{}'; the members are: "
-                            "threads", triple, ak)));
+                            "threads, exceptions", triple, ak)));
                     if (!av.is_bool())
                         return std::unexpected(error(origin, std::format(
-                            "[target.{}.abi].threads must be true or false", triple)));
-                    cc.abiThreads = av.as_bool();
-                    cc.abiThreadsDeclared = true;
+                            "[target.{}.abi].{} must be true or false", triple, ak)));
+                    if (ak == "threads") {
+                        cc.abiThreads = av.as_bool();
+                        cc.abiThreadsDeclared = true;
+                    } else {
+                        cc.abiExceptions = av.as_bool();
+                        cc.abiExceptionsDeclared = true;
+                    }
+                }
+            }
+            // `[target.<pred>] requires_abi = { ... }` -- design 2026-09-12
+            // (the UI framework record), section 2.6, A6: the requirement can
+            // sit on the TARGET axis, because the sources it gates
+            // (`[target.<pred>.build] sources`) are selected by this same
+            // predicate. A DIRECT key of the selector table (an inline-table
+            // VALUE), not a sub-section -- which is why the unsupported-key
+            // sweep above does not have to name it: that sweep skips every
+            // table-valued key, on the reasoning that a table is the
+            // conditional channel, and an inline table is the same TOML value
+            // shape as a dotted sub-section. Stored on `cc` and unioned into
+            // the package's requirement set by `merge_conditional_config`
+            // when the predicate matches the resolved target, keeping the
+            // selector text so a refusal can name what asked.
+            //
+            // MEASURED: an mcpp before this change (2026.9.12.2) neither
+            // warns nor errors on this key -- it is a table, so the same
+            // "skip tables" sweep already silently drops it there too. The
+            // design record's claim that an older engine warns
+            // "[target.cfg(linux)] has unsupported key 'requires_abi'
+            // (ignored)" does not hold for 2026.9.12.2; verified by running
+            // it against `[target.'cfg(linux)'] requires_abi = { threads =
+            // true }`, which built with no diagnostic at all.
+            if (auto rait2 = body.find("requires_abi"); rait2 != body.end()) {
+                if (!rait2->second.is_table())
+                    return std::unexpected(error(origin, std::format(
+                        "[target.{}] requires_abi must be a table such as "
+                        "`{{ threads = true }}`", triple)));
+                for (auto& [ak, av] : rait2->second.as_table()) {
+                    if ((ak != "threads" && ak != "exceptions") || !av.is_bool())
+                        return std::unexpected(error(origin, std::format(
+                            "[target.{}].requires_abi.{}: the members are "
+                            "`threads`, `exceptions`, booleans", triple, ak)));
+                    if (ak == "threads") cc.requiresAbiThreads = av.as_bool();
+                    else cc.requiresAbiExceptions = av.as_bool();
+                }
+            }
+            // `[target.<pred>.feature-requires-abi] <feature> = { ... }` --
+            // the per-feature form of the same requirement, on the target
+            // axis. Named after `feature-deps` and `feature-xlings` below,
+            // the two existing per-target-per-feature tables. The feature is
+            // registered UNCONDITIONALLY, exactly as `feature-deps` does a
+            // few dozen lines down: whether the predicate matches decides
+            // whether the requirement counts, not whether the feature exists.
+            if (auto frait = body.find("feature-requires-abi");
+                frait != body.end() && frait->second.is_table()) {
+                for (auto& [fname, fval] : frait->second.as_table()) {
+                    if (!fval.is_table())
+                        return std::unexpected(error(origin, std::format(
+                            "[target.{}.feature-requires-abi.{}] must be a "
+                            "table such as `{{ threads = true }}`", triple, fname)));
+                    for (auto& [ak, av] : fval.as_table()) {
+                        if ((ak != "threads" && ak != "exceptions") || !av.is_bool())
+                            return std::unexpected(error(origin, std::format(
+                                "[target.{}.feature-requires-abi.{}].{}: the "
+                                "members are `threads`, `exceptions`, booleans",
+                                triple, fname, ak)));
+                        if (ak == "threads")
+                            cc.featureRequiresAbiThreads[std::string(fname)] = av.as_bool();
+                        else
+                            cc.featureRequiresAbiExceptions[std::string(fname)] = av.as_bool();
+                    }
+                    m.featuresMap.try_emplace(std::string(fname),
+                                              std::vector<std::string>{});
                 }
             }
             if (auto rit = body.find("runtime"); rit != body.end() && rit->second.is_table()) {
 
@@ -821,6 +821,20 @@ struct BuildConfig : BuildInputs {
     // value because `threads = false` is also a statement.
     bool                               abiThreads = false;
     bool                               abiThreadsDeclared = false;
+    // `[target.<selector>.abi] exceptions` -- design 2026-09-12 (the UI
+    // framework record) section 2.1, A1: the second member of the table.
+    // Whether the artefact is built with C++ exceptions on. A GRAPH-WIDE ABI
+    // SWITCH for the same reason `threads` is one: clang records the
+    // exception model in a BMI and refuses an importer that disagrees, so
+    // the switch must reach the standard library prebuild, the scan, every
+    // translation unit, and the link. Rendered only where the target's
+    // default is OFF -- Emscripten; every hosted target already links with
+    // exceptions on, so the member is satisfied by default there, the same
+    // property `threads` has on PE. Declared is kept apart from the value
+    // for the same reason `threads` keeps it: `exceptions = false` is also
+    // a statement.
+    bool                               abiExceptions = false;
+    bool                               abiExceptionsDeclared = false;
     std::string                         cStandard;
     // Escape hatch for the hermetic link check: a sandbox toolchain whose
     // CRT/loader resolve OUTSIDE the sandbox is a hard error by default
@@ -1298,6 +1312,24 @@ struct ConditionalConfig {
     // BuildConfig::abiThreads for what the value does and where it applies.
     bool                                abiThreads = false;
     bool                                abiThreadsDeclared = false;
+    // `[target.<sel>.abi] exceptions` -- see BuildConfig::abiExceptions.
+    bool                                abiExceptions = false;
+    bool                                abiExceptionsDeclared = false;
+    // `[target.<sel>] requires_abi = { ... }` -- design 2026-09-12 (the UI
+    // framework record) section 2.6, A6: a requirement can sit on the target
+    // axis, because the sources it gates (`[target.<sel>.build] sources`) are
+    // selected by this SAME predicate. No "declared" pair: a requirement is a
+    // union (this selector asks, or it does not), so `false` carries nothing
+    // a plain absence would not -- unlike `abi`'s value, which the root
+    // renders and where `false` overrides an outer `true`.
+    bool                                requiresAbiThreads = false;
+    bool                                requiresAbiExceptions = false;
+    // `[target.<sel>.feature-requires-abi] <feature> = { ... }` -- the
+    // per-feature form of the same requirement, on the target axis. Named
+    // after `feature-deps`/`feature-xlings` below, the two existing
+    // per-target-per-feature tables (SPEC-004 section 4; #359).
+    std::map<std::string, bool>        featureRequiresAbiThreads;
+    std::map<std::string, bool>        featureRequiresAbiExceptions;
     // Conditional dependencies (Phase 1b): merged into the corresponding
     // manifest maps in prepare_build when the predicate matches the resolved
     // target — before dependency resolution, so they resolve like any dep.
@@ -1365,7 +1397,9 @@ inline bool is_empty(const ConditionalConfig& c) {
         && c.frameworks.empty()
         && c.dependencies.empty() && c.devDependencies.empty()
         && c.buildDependencies.empty() && c.featureDeps.empty()
-        && c.xlings.empty() && !c.abiThreadsDeclared;
+        && c.xlings.empty() && !c.abiThreadsDeclared && !c.abiExceptionsDeclared
+        && !c.requiresAbiThreads && !c.requiresAbiExceptions
+        && c.featureRequiresAbiThreads.empty() && c.featureRequiresAbiExceptions.empty();
 }
 
 // `[lib]` — library "root" interface convention.
@@ -1697,12 +1731,28 @@ struct Manifest {
     // through untouched, exactly as they do in `provides`.
     // The spelling is `requires_` because `requires` is a keyword.
     std::vector<std::string>                        requires_;
-    // `requires_abi = { threads = true }` at package level, and per feature.
-    // A statement that the ARTEFACT's ABI has a switch on, compared at
-    // resolution with the root's `[target.<selector>.abi]`. Only `threads`
-    // exists; a feature's entry counts only when that feature is active.
+    // `requires_abi = { threads = true, exceptions = true }` at package
+    // level, and per feature. A statement that the ARTEFACT's ABI has a
+    // switch on, compared at resolution with the root's
+    // `[target.<selector>.abi]`. A feature's entry counts only when that
+    // feature is active.
     bool                                            requiresAbiThreads = false;
+    bool                                            requiresAbiExceptions = false;
     std::map<std::string, bool>                     featureRequiresAbiThreads;
+    std::map<std::string, bool>                     featureRequiresAbiExceptions;
+    // The TARGET-AXIS form of the same requirement (design 2026-09-12, the UI
+    // framework record, section 2.6, A6): `[target.<sel>] requires_abi =
+    // {...}` and `[target.<sel>.feature-requires-abi] <f> = {...}`, unioned
+    // in by `merge_conditional_config` when the selector matches the resolved
+    // target. Kept apart from the two members above -- rather than folded
+    // into them -- so the check that reports an unmet requirement can name
+    // the SELECTOR that asked, as written, and not just "the package": each
+    // vector holds the predicate text of every matching selector that
+    // declared the member, in the order merge_conditional_config visited them.
+    std::vector<std::string>                        targetRequiresAbiThreads;
+    std::vector<std::string>                        targetRequiresAbiExceptions;
+    std::map<std::string, std::vector<std::string>> targetFeatureRequiresAbiThreads;
+    std::map<std::string, std::vector<std::string>> targetFeatureRequiresAbiExceptions;
     // [package] exclusive — the capabilities this package claims it is the ONLY
     // provider of.
     //