diff --git a/AGENTS.md b/AGENTS.md
index 8c9e498..bbaa462 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -97,9 +97,19 @@ There is no Vapor CI gate until Vue 3.6 is stable; the constraint is upheld by r
   **not** safe next to a `{{ }}` interpolation, which condenses to a single space instead. Render
   every label through `QueryBuilderLabel` (a component, so it counts as an element) rather than
   interpolating.
-- Every default control sets `inheritAttrs: false`. `Rule`/`RuleGroup` hand each subcomponent a
-  common prop bag (`rule`, `rules`, `ruleOrGroup`, `fieldData`, ...) that most of them do not
-  declare; without this those land on the DOM as stray attributes React never emits.
+- No default control sets `inheritAttrs: false`; attribute fallthrough is on, as Vue developers
+  expect. Two invariants keep stray attributes off the DOM, and both are gated against core's
+  `controlPropKeys` — at runtime by `src/components/controlProps.test.ts`, at compile time by
+  `src/types/types.test-d.ts`:
+  1. every default control **declares** every prop its control keys receive (`ValueSelector`
+     therefore declares `VersatileSelectorProps`, the union across the five selector keys it is
+     the default for), and
+  2. `Rule`/`RuleGroup`/`RuleComponents`/`RuleGroupHeader`/`RuleGroupBody` **pass** nothing
+     beyond those keys — which is why `rule` is bound per-control rather than folded into the
+     `common` bag.
+     A new control prop must be added to both sides.
+- Bulk-override membership (`actionElement`, `valueSelector`) comes from core's `controlKind`,
+  never from sniffing the key name. `shiftActions`/`undoRedoActions` are not bulk targets.
 
 ### Slots
 
@@ -126,7 +136,7 @@ loader and guards it; it runs as part of `check:exports`.
 
 - The query is a `shallowRef`. A deep proxy defeats reference comparisons and is rejected by the manager's Immer deep-freeze.
 - Always `toRaw()` a query before handing it to the manager.
-- Likewise `toRaw()` the **manager itself** before calling it. `QueryManager` keeps its history in private class fields, which a reactive `Proxy` cannot read through (`Cannot read private member #past`). `schema` is an ordinary computed value in normal use, but Vue Test Utils wraps mount props in `reactive`, and nothing stops a consumer from doing the same.
+- Do **not** `toRaw()` the manager. As of `@react-querybuilder/core` 8.23.0 `QueryManager` keeps its state in a single non-enumerable, symbol-keyed own property that forwards through a `Proxy`'s `get` trap, and that property carries `__v_skip`, so `reactive()` neither breaks it nor deep-proxies its internals. This matters because Vue Test Utils wraps mount props in `reactive`, so a proxied `schema.manager` arrives by accident. Before 8.23.0 the state was in `#private` fields and every call threw `Cannot read private member #past`; `useQueryBuilder.test.ts` covers the proxy cycle.
 - A `useRule`/`useRuleGroup` return object reaches the internal components through **provide/inject**, not as a prop — see `src/internal/parts.ts`. It is unwrapped with `reactive()` exactly once, at the provider: Vue auto-unwraps refs only for top-level `setup` bindings, and `reactive()` on a container of refs yields each `.value` directly while leaving plain handler functions alone. Consumers inject and destructure; none of them calls `reactive()` itself.
 - `RuleSubQuery` provides the subquery's group under **both** the subquery key and the group key, so the `RuleGroupHeader`/`RuleGroupBody` that `RuleComponents` renders resolve the subquery's group rather than the enclosing one. `Rule` correspondingly shadows the subquery key with `undefined`, so a rule nested inside a subquery is not mistaken for one.
 - The **public** injection accessors (`useSchema`, `useQueryBuilderActions`, `useCurrentRule`, `useCurrentRuleGroup`, `useCurrentPath`) use their own keys in `src/composables/accessors.ts`. Keep them separate from the internal keys: the internal shape is not public API. `Rule`/`RuleGroup` re-provide schema and actions at every level so a subquery's descendants see the subquery's own.
@@ -186,6 +196,15 @@ specifiers, `exports`-map targets and condition order, built-artifact module-cyc
 `test:coverage` (three thresholds), `conformance` (DOM parity, 232 tests), `test:ssr`, and the
 a11y suite (`src/components/a11y.test.ts`, part of the default run).
 
+The fallthrough gate (`src/components/controlProps.test.ts`) is proven red two ways: fold `rule`
+back into `RuleComponents`' `common` bag (the "passes nothing extra" half), or narrow
+`ValueSelector` back to `ValueSelectorProps` (the "declares everything" half). Its compile-time
+twin in `src/types/types.test-d.ts` is proven red by deleting any prop from a control's props
+interface.
+
+The proxy-safe-manager gate (`useQueryBuilder.test.ts`, "drives a manager wrapped in
+`reactive()`") is proven red by pinning `@react-querybuilder/core` below 8.23.0.
+
 The a11y gate is proven red by removing the `title` binding from `ValueSelector.vue`, which turns
 all eight axe cases red.
 
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 87ff51f..66b2004 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -27,6 +27,10 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 - **`Label` is renamed to `QueryBuilderLabel`** (and `LabelProps` to `QueryBuilderLabelProps`).
   **Breaking, with no deprecated alias.** `Label` is far too generic for a top-level export and
   a likely collision in any globally registered setup.
+- **`controlKeys` is no longer exported from this package.** **Breaking in name only:** the
+  package re-exports `@react-querybuilder/core`, whose 8.23.0 `controlKeys` takes over the name.
+  Core's list is a superset — it includes the three controls this port does not implement
+  (`dragHandle`, `ruleGroupHeaderElements`, `ruleGroupBodyElements`).
 - **`RuleComponents`, `RuleGroupHeader`, `RuleGroupBody`, and `RuleSubQuery` are no longer
   exported**, and their prop types are gone with them. **Breaking.** The docs always described
   them as internal; they now read everything they render through injection and cannot be
@@ -35,6 +39,25 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Changed
 
+- **Minimum `@react-querybuilder/core` is 8.23.0.** That release makes `QueryManager` readable
+  through a `Proxy` and adds the `controlKeys`/`controlPropKeys`/`controlKind` data this package
+  now builds on. (Until 8.23.0 ships, the dependency points at a pkg.pr.new pre-release build.)
+- **A `QueryManager` may be wrapped in `reactive()`.** The `toRaw(manager)` calls are gone from
+  `useQueryBuilder` and `UndoRedoActions`; the manager's state now reads correctly through a
+  proxy, and `reactive()` will not deep-proxy its internals. Vue Test Utils wraps mount props in
+  `reactive`, so this footgun was hit by accident rather than by choice. `toRaw()` on the
+  **query** is unchanged — Immer's deep-freeze is a separate concern.
+- **Attribute fallthrough is enabled on every default control.** `inheritAttrs: false` is gone
+  from all nine, so a consumer-supplied `class`, `id`, or listener lands on the rendered element
+  the way a Vue developer expects. Nothing strays there: `ValueSelector` now declares
+  `VersatileSelectorProps` (the union of the five selector control prop sets it is the default
+  for), and `Rule`/`RuleGroup` pass exactly the keys core's `controlPropKeys` lists — `rule` is
+  bound only on the controls that actually take it, rather than on every subcomponent. A runtime
+  test and a compile-time test gate both halves against core.
+- **`shiftActions` and `undoRedoActions` are no longer targets of the `actionElement` bulk
+  override.** **Breaking, if you relied on it.** Membership now comes from core's `controlKind`
+  instead of a `key.endsWith('Action'/'Actions')` test, which matches React. Both controls still
+  render their buttons through the `actionElement` control, so an override reaches them that way.
 - Structural manager options are now reactive. `fields`, `operators`, `combinators`,
   `baseField`/`baseOperator`/`baseCombinator`, `translations`, `maxLevels`, `disabled`, the
   `autoSelect*`/`resetOn*`/`listsAsArrays`/`addRuleToNewGroups` flags, `validator`, and
diff --git a/bun.lock b/bun.lock
index b2a1ec5..ae2a823 100644
--- a/bun.lock
+++ b/bun.lock
@@ -54,7 +54,7 @@
       "name": "@react-querybuilder/vue",
       "version": "0.2.0",
       "dependencies": {
-        "@react-querybuilder/core": "^8.22.3",
+        "@react-querybuilder/core": "https://pkg.pr.new/react-querybuilder/react-querybuilder/@react-querybuilder/core@a784003",
       },
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.18.5",
@@ -397,7 +397,7 @@
 
     "@poppinss/exception": ["@poppinss/exception@1.2.3", "", {}, "sha512-dCED+QRChTVatE9ibtoaxc+WkdzOSjYTKi/+uacHWIsfodVfpsueo3+DKpgU5Px8qXjgmXkSvhXvSCz3fnP9lw=="],
 
-    "@react-querybuilder/core": ["@react-querybuilder/core@8.22.3", "", { "dependencies": { "@ts-jison/lexer": "0.4.1-alpha.1", "@ts-jison/parser": "0.4.1-alpha.1", "immer": "^11.1.15", "numeric-quantity": "^3.2.2" }, "peerDependencies": { "@tanstack/db": ">=0.6.9", "@traqula/parser-sparql-1-2": ">=0.1.0", "chevrotain": ">=11", "drizzle-orm": ">=0.38.0", "json-logic-js": ">=2", "jsonata": ">=2", "sequelize": ">=6", "spel2js": ">=0.2.0" }, "optionalPeers": ["@tanstack/db", "@traqula/parser-sparql-1-2", "chevrotain", "drizzle-orm", "json-logic-js", "jsonata", "sequelize", "spel2js"] }, "sha512-/0sJI40ByEb2N+u5Y6PfrOMHN2usmAtFAqay1WALKolCMhurV+z/ZZ5ANAOTcwBTyATvga0sdEYdhudZO5WEvA=="],
+    "@react-querybuilder/core": ["@react-querybuilder/core@https://pkg.pr.new/react-querybuilder/react-querybuilder/@react-querybuilder/core@a784003", { "dependencies": { "@ts-jison/lexer": "0.4.1-alpha.1", "@ts-jison/parser": "0.4.1-alpha.1", "@types/json-logic-js": ">=2", "immer": "^11.1.16", "numeric-quantity": "^3.2.2" }, "peerDependencies": { "@tanstack/db": ">=0.6.9", "@traqula/parser-sparql-1-2": ">=0.1.0", "chevrotain": ">=11", "drizzle-orm": ">=0.38.0", "json-logic-js": ">=2", "jsonata": ">=2", "sequelize": ">=6", "spel2js": ">=0.2.0" }, "optionalPeers": ["@tanstack/db", "@traqula/parser-sparql-1-2", "chevrotain", "drizzle-orm", "json-logic-js", "jsonata", "sequelize", "spel2js"] }, "sha512-WHxhs4DFfM6xC9PrnDckgWOAT9NlRHHpinq5AZ9Z6gzmVa4pY1mlPLIo0I/oF+cmYDEcip1q6JUG7XL2dN/Fiw=="],
 
     "@react-querybuilder/vue": ["@react-querybuilder/vue@workspace:packages/vue-querybuilder"],
 
@@ -535,6 +535,8 @@
 
     "@types/jsesc": ["@types/jsesc@2.5.1", "", {}, "sha512-9VN+6yxLOPLOav+7PwjZbxiID2bVaeq0ED4qSQmdQTdjnXJSaCVKTR58t15oqH1H5t8Ng2ZX1SabJVoN9Q34bw=="],
 
+    "@types/json-logic-js": ["@types/json-logic-js@2.0.8", "", {}, "sha512-WgNsDPuTPKYXl0Jh0IfoCoJoAGGYZt5qzpmjuLSEg7r0cKp/kWtWp0HAsVepyPSPyXiHo6uXp/B/kW/2J1fa2Q=="],
+
     "@types/node": ["@types/node@26.1.2", "", { "dependencies": { "undici-types": "~8.3.0" } }, "sha512-Vu4a5UFA9rIIFJ7rB/Vaafh9lrCQszopTCx6KjFboXTGQbPNasehVR5TEiithSDGyd1DEiUByggTZsg8jukeIg=="],
 
     "@types/resolve": ["@types/resolve@1.20.2", "", {}, "sha512-60BCwRFOZCQhDncwQdxxeOEEkbc5dIMccYLwbxsS4TUNeVECQ/pBJ0j09mrHOl/JJvpRPGwO9SvE4nR2Nb/a4Q=="],
diff --git a/docs/customization.md b/docs/customization.md
index caee6ed..5de7f19 100644
--- a/docs/customization.md
+++ b/docs/customization.md
@@ -180,7 +180,6 @@ package barrel:
 <script setup lang="ts">
 import type { ValueEditorProps } from '@react-querybuilder/vue';
 
-defineOptions({ inheritAttrs: false });
 const props = defineProps<ValueEditorProps>();
 </script>
 
@@ -195,8 +194,11 @@ const props = defineProps<ValueEditorProps>();
 </template>
 ```
 
-Set `inheritAttrs: false`. `Rule` and `RuleGroup` hand every subcomponent a common prop bag, and
-anything a replacement does not declare would otherwise land on the DOM as a stray attribute.
+Declaring the full props type is enough: `Rule` and `RuleGroup` pass exactly the props each
+control's type lists, so nothing is left over to fall through, and normal Vue attribute
+fallthrough stays available for whatever a consumer of _your_ component passes. If you declare
+only a subset of the props, set `inheritAttrs: false` so the rest do not land on the DOM as
+stray attributes.
 
 Keep `data-testid`, `class`, and `title` if you want the standard stylesheets — and any tests
 written against the standard DOM — to keep working.
diff --git a/docs/differences-from-react-querybuilder.md b/docs/differences-from-react-querybuilder.md
index 4b95512..bc4b480 100644
--- a/docs/differences-from-react-querybuilder.md
+++ b/docs/differences-from-react-querybuilder.md
@@ -76,8 +76,12 @@ const log = () => console.log(formatQuery(manager.getQuery(), 'sql'));
 </template>
 ```
 
-`QueryManager` keeps its history in private class fields, which a reactive `Proxy` cannot read
-through. Do not wrap a manager in `reactive()`; if you must, `toRaw()` it before calling it.
+A manager may be wrapped in `reactive()` — Vue Test Utils does exactly that to mount props, so
+it happens by accident more often than by choice. As of `@react-querybuilder/core` 8.23.0 the
+manager's state lives in a non-enumerable, symbol-keyed own property, which reads correctly
+through a `Proxy`, and that property is flagged so `reactive()` will not deep-proxy the internals
+either. No `toRaw()` is required. (Before 8.23.0 the state was in `#private` fields and every
+call through a proxy threw `Cannot read private member #past`.)
 
 ## 4. Query binding
 
@@ -156,8 +160,10 @@ Consequences worth spelling out:
   directly to `QueryBuilder` beats an inherited slot, because levels are tried before sources.
 - `controlElements: { x: null }` short-circuits at its own level, so it renders nothing even when
   an outer provider supplies an `#x` slot.
-- Bulk sources are `actionElement` (keys ending `Action`/`Actions`) and `valueSelector` (keys
-  ending `Selector`). They never apply to `valueEditor`, `rule`, `ruleGroup`, `inlineCombinator`,
+- Bulk sources are `actionElement` and `valueSelector`. Membership comes from core's
+  `controlKind`, not from sniffing the key name: `shiftActions` and `undoRedoActions` (plural)
+  are **not** targets of the `actionElement` bulk override, matching React. Their buttons still
+  render through the `actionElement` control, so an override reaches them that way. They never apply to `valueEditor`, `rule`, `ruleGroup`, `inlineCombinator`,
   `notToggle`, or `matchModeEditor`.
 
 Because slots must be inheritable, they also have a prop form: `QueryBuilderContextProps.slots`,
@@ -271,10 +277,13 @@ Notes:
   rebuilt on every render does not retrigger it.
 - **`ValueSelector` drives a multi-select through each `<option>`'s `selected` attribute**, not a
   `value` binding, which Vue would stringify into a cleared selection. Rendered DOM is unchanged.
-- **Every default control sets `inheritAttrs: false`.** `Rule` and `RuleGroup` hand each
-  subcomponent a common prop bag (`rule`, `rules`, `ruleOrGroup`, `fieldData`, …) that most
-  controls do not declare; without this, Vue would land them on the DOM as stray attributes React
-  never emits. A custom control should do the same.
+- **Attribute fallthrough is on for every default control**, so a consumer-supplied `class`,
+  `id`, or listener behaves the way a Vue developer expects. Nothing strays onto the DOM on its
+  own: each control declares every prop core's `controlPropKeys` says it receives, and the call
+  sites pass nothing beyond that. Both halves are gated — at runtime by
+  `components/controlProps.test.ts` and at compile time by `types/types.test-d.ts` — so drift
+  from React surfaces as a failing check rather than as a stray attribute. A replacement control
+  that does not declare the full prop set should set `inheritAttrs: false`.
 - **Every boolean prop is declared with an explicit `undefined` default.** Vue casts an omitted
   `Boolean` prop to `false`, which is not the same as "not configured" — `autoSelectField`,
   `enableMountQueryChange`, and the `resetOn*` flags all default to `true`, and a stray `false`
diff --git a/packages/vue-querybuilder/package.json b/packages/vue-querybuilder/package.json
index 5552d79..aaf4a0d 100644
--- a/packages/vue-querybuilder/package.json
+++ b/packages/vue-querybuilder/package.json
@@ -65,7 +65,7 @@
     "vue": "^3.5"
   },
   "dependencies": {
-    "@react-querybuilder/core": "^8.22.3"
+    "@react-querybuilder/core": "https://pkg.pr.new/react-querybuilder/react-querybuilder/@react-querybuilder/core@a784003"
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.18.5",
diff --git a/packages/vue-querybuilder/src/components/ActionElement.vue b/packages/vue-querybuilder/src/components/ActionElement.vue
index 9a784e6..cd00138 100644
--- a/packages/vue-querybuilder/src/components/ActionElement.vue
+++ b/packages/vue-querybuilder/src/components/ActionElement.vue
@@ -8,10 +8,11 @@ import type { ActionProps } from '../types/props.js';
  *
  * Port of React Query Builder's `ActionElement` (`ActionElement.tsx`).
  */
-// `inheritAttrs: false`: `Rule`/`RuleGroup` pass every subcomponent a common set of props
-// (`rule`, `rules`, `ruleOrGroup`, ...) that this component does not declare. Without this they
-// would fall through onto the `<button>` as stray attributes, which React never emits.
-defineOptions({ name: 'ActionElement', inheritAttrs: false });
+// Attribute fallthrough is on, as a Vue developer expects: a consumer-supplied `class`, `id`,
+// or listener lands on the `<button>`. Nothing strays there on its own — `ActionProps` declares
+// every prop core's `controlPropKeys` says an action control receives, and the call sites pass
+// nothing beyond that. `controlProps.test.ts` gates both halves.
+defineOptions({ name: 'ActionElement' });
 
 const props = defineProps<ActionProps>();
 
diff --git a/packages/vue-querybuilder/src/components/InlineCombinator.vue b/packages/vue-querybuilder/src/components/InlineCombinator.vue
index da7b523..5cfd63c 100644
--- a/packages/vue-querybuilder/src/components/InlineCombinator.vue
+++ b/packages/vue-querybuilder/src/components/InlineCombinator.vue
@@ -10,8 +10,8 @@ import type { CombinatorSelectorProps, InlineCombinatorProps } from '../types/pr
  *
  * Port of React Query Builder's `InlineCombinator` (`InlineCombinator.tsx`).
  */
-// `inheritAttrs: false`: see `ActionElement.vue`.
-defineOptions({ name: 'InlineCombinator', inheritAttrs: false });
+// Attribute fallthrough is on; see `ActionElement.vue`.
+defineOptions({ name: 'InlineCombinator' });
 
 const props = defineProps<InlineCombinatorProps>();
 
diff --git a/packages/vue-querybuilder/src/components/MatchModeEditor.vue b/packages/vue-querybuilder/src/components/MatchModeEditor.vue
index 7328097..becb118 100644
--- a/packages/vue-querybuilder/src/components/MatchModeEditor.vue
+++ b/packages/vue-querybuilder/src/components/MatchModeEditor.vue
@@ -13,9 +13,10 @@ import type { Schema } from '../types/schema.js';
  * Both controls carry the same `testID`, as upstream does, so tests reach the threshold editor
  * with `getAllByTestId(...)[1]`.
  */
-// `inheritAttrs: false`: see `ActionElement.vue`. This component renders two roots, so Vue would
-// not know where to put fallthrough attributes anyway.
-defineOptions({ name: 'MatchModeEditor', inheritAttrs: false });
+// Attribute fallthrough is on; see `ActionElement.vue`. This component renders two roots, so a
+// stray attribute would draw a Vue warning rather than land silently — which is the behavior a
+// Vue developer expects, and `controlProps.test.ts` proves none strays.
+defineOptions({ name: 'MatchModeEditor' });
 
 const dummyFieldData: FullField = { name: '', value: '', label: '' };
 const dummyPath: Path = [];
diff --git a/packages/vue-querybuilder/src/components/NotToggle.test.ts b/packages/vue-querybuilder/src/components/NotToggle.test.ts
index e423e98..16c16cd 100644
--- a/packages/vue-querybuilder/src/components/NotToggle.test.ts
+++ b/packages/vue-querybuilder/src/components/NotToggle.test.ts
@@ -86,11 +86,16 @@ describe('NotToggle', () => {
     expect(nodes[1].textContent).toBe('Not');
   });
 
-  it('does not let undeclared props fall through as attributes', () => {
+  // Attribute fallthrough is enabled, so a consumer-supplied attribute reaches the DOM and a
+  // consumer-supplied `class` merges with the control's own. Nothing the port passes internally
+  // strays here; `controlProps.test.ts` is the gate for that.
+  it('passes consumer-supplied attributes through to the root element', () => {
     const { getByTestId } = render(NotToggle, {
-      props: { ...baseProps(), testID: 'x' },
-      attrs: { rules: [] },
+      props: { ...baseProps(), className: 'own-cn', testID: 'x' },
+      attrs: { id: 'consumer-id', class: 'consumer-cn' },
     });
-    expect(getByTestId('x')).not.toHaveAttribute('rules');
+    const el = getByTestId('x');
+    expect(el).toHaveAttribute('id', 'consumer-id');
+    expect(el).toHaveClass('own-cn', 'consumer-cn');
   });
 });
diff --git a/packages/vue-querybuilder/src/components/NotToggle.vue b/packages/vue-querybuilder/src/components/NotToggle.vue
index 19895ac..766ba49 100644
--- a/packages/vue-querybuilder/src/components/NotToggle.vue
+++ b/packages/vue-querybuilder/src/components/NotToggle.vue
@@ -8,10 +8,8 @@ import type { NotToggleProps } from '../types/props.js';
  *
  * Port of React Query Builder's `NotToggle` (`NotToggle.tsx`).
  */
-// `inheritAttrs: false`: `RuleGroup` passes every subcomponent a common set of props
-// (`ruleGroup`, `rules`, ...) that this component does not declare. Without this they would
-// fall through onto the `<label>` as stray attributes, which React never emits.
-defineOptions({ name: 'NotToggle', inheritAttrs: false });
+// Attribute fallthrough is on; see `ActionElement.vue`.
+defineOptions({ name: 'NotToggle' });
 
 const props = defineProps<NotToggleProps>();
 
diff --git a/packages/vue-querybuilder/src/components/ShiftActions.test.ts b/packages/vue-querybuilder/src/components/ShiftActions.test.ts
index 13da706..d548639 100644
--- a/packages/vue-querybuilder/src/components/ShiftActions.test.ts
+++ b/packages/vue-querybuilder/src/components/ShiftActions.test.ts
@@ -72,11 +72,12 @@ describe('ShiftActions', () => {
     expect(getByTestId('x')).toBeInTheDocument();
   });
 
-  it('does not let undeclared props fall through as attributes', () => {
+  // See `NotToggle.test.ts`: fallthrough is the point of dropping `inheritAttrs: false`.
+  it('passes consumer-supplied attributes through to the root element', () => {
     const { getByTestId } = render(ShiftActions, {
       props: { ...baseProps(), testID: 'x' },
-      attrs: { rules: [] },
+      attrs: { id: 'consumer-id' },
     });
-    expect(getByTestId('x')).not.toHaveAttribute('rules');
+    expect(getByTestId('x')).toHaveAttribute('id', 'consumer-id');
   });
 });
diff --git a/packages/vue-querybuilder/src/components/ShiftActions.vue b/packages/vue-querybuilder/src/components/ShiftActions.vue
index ebb216a..9d1ce44 100644
--- a/packages/vue-querybuilder/src/components/ShiftActions.vue
+++ b/packages/vue-querybuilder/src/components/ShiftActions.vue
@@ -10,8 +10,8 @@ import type { ShiftActionsProps } from '../types/props.js';
  * The click event is forwarded to `shiftUp`/`shiftDown` because `Rule`/`RuleGroup` read
  * `event.altKey` to decide whether to shift the rule/group into or out of the adjacent group.
  */
-// `inheritAttrs: false`: see `ActionElement.vue`.
-defineOptions({ name: 'ShiftActions', inheritAttrs: false });
+// Attribute fallthrough is on; see `ActionElement.vue`.
+defineOptions({ name: 'ShiftActions' });
 
 const props = defineProps<ShiftActionsProps>();
 </script>
diff --git a/packages/vue-querybuilder/src/components/UndoRedoActions.test.ts b/packages/vue-querybuilder/src/components/UndoRedoActions.test.ts
index 1a26dee..2d3359a 100644
--- a/packages/vue-querybuilder/src/components/UndoRedoActions.test.ts
+++ b/packages/vue-querybuilder/src/components/UndoRedoActions.test.ts
@@ -3,7 +3,7 @@ import { QueryManager } from '@react-querybuilder/core';
 import userEvent from '@testing-library/user-event';
 import { render } from '@testing-library/vue';
 import { describe, expect, it } from 'vitest';
-import { defineComponent, h, nextTick } from 'vue';
+import { defineComponent, h, nextTick, reactive } from 'vue';
 import type { Schema } from '../types/schema.js';
 import { defaultControlElements } from './defaultControlElements.js';
 import UndoRedoActions from './UndoRedoActions.vue';
@@ -86,6 +86,21 @@ describe('UndoRedoActions', () => {
     expect(getByTestId('redo-action')).toBeDisabled();
   });
 
+  it('reads history off a manager that arrived through `reactive()`', async () => {
+    const { manager, props } = setup();
+    manager.update('value', 'changed', [0]);
+    const base = props();
+    // Vue Test Utils wraps mount props in `reactive`, so this is the accidental case, not an
+    // exotic one. `QueryManager` is proxy-safe as of core 8.23.0.
+    const { getByTestId } = render(UndoRedoActions, {
+      props: reactive({ ...base }) as typeof base,
+    });
+    await nextTick();
+    expect(getByTestId('undo-action')).toBeEnabled();
+    await userEvent.click(getByTestId('undo-action'));
+    expect(manager.getQuery().rules[0]).toMatchObject({ value: 'v1' });
+  });
+
   it('renders through a replacement `actionElement`', () => {
     const { props } = setup();
     const Replacement = defineComponent({
diff --git a/packages/vue-querybuilder/src/components/UndoRedoActions.vue b/packages/vue-querybuilder/src/components/UndoRedoActions.vue
index 1e2a35a..17b79a9 100644
--- a/packages/vue-querybuilder/src/components/UndoRedoActions.vue
+++ b/packages/vue-querybuilder/src/components/UndoRedoActions.vue
@@ -1,6 +1,6 @@
 <script setup lang="ts">
 import { TestID } from '@react-querybuilder/core';
-import { computed, toRaw } from 'vue';
+import { computed } from 'vue';
 import type { UndoRedoActionsProps } from '../types/props.js';
 
 /**
@@ -14,16 +14,15 @@ import type { UndoRedoActionsProps } from '../types/props.js';
  * The buttons themselves render through the `actionElement` control, so a replacement applies
  * here too.
  */
-// `inheritAttrs: false`: see `ActionElement.vue`.
-defineOptions({ name: 'UndoRedoActions', inheritAttrs: false });
+// Attribute fallthrough is on; see `ActionElement.vue`.
+defineOptions({ name: 'UndoRedoActions' });
 
 const props = defineProps<UndoRedoActionsProps>();
 
-// `toRaw`: `QueryManager` keeps its history in private class fields, which a reactive Proxy
-// cannot read through (`Cannot read private member #past`). `schema` is a plain computed value
-// in normal use, but nothing stops a caller — or a test harness such as Vue Test Utils, which
-// wraps mount props in `reactive` — from handing over a proxied one.
-const manager = computed(() => toRaw(props.schema.manager));
+// No `toRaw`: `QueryManager` is proxy-safe as of `@react-querybuilder/core` 8.23.0, so a
+// `schema` that arrived through `reactive()` (Vue Test Utils wraps mount props that way) reads
+// its history correctly.
+const manager = computed(() => props.schema.manager);
 const actionElement = computed(() => props.schema.controls.actionElement);
 
 // `canUndo`/`canRedo` are plain method calls on a stable object, so they carry no reactivity of
diff --git a/packages/vue-querybuilder/src/components/ValueEditor.vue b/packages/vue-querybuilder/src/components/ValueEditor.vue
index 92c157b..a053eef 100644
--- a/packages/vue-querybuilder/src/components/ValueEditor.vue
+++ b/packages/vue-querybuilder/src/components/ValueEditor.vue
@@ -22,8 +22,8 @@ import type { ValueEditorProps, ValueSelectorProps } from '../types/props.js';
  * hazard — the effect that resets a value when it stops representing a list — lives in
  * `useValueEditorReset`; everything else is a plain derivation.
  */
-// See `ActionElement.vue` for why attribute fallthrough is disabled.
-defineOptions({ name: 'ValueEditor', inheritAttrs: false });
+// Attribute fallthrough is on; see `ActionElement.vue`.
+defineOptions({ name: 'ValueEditor' });
 
 const props = defineProps<ValueEditorProps>();
 
diff --git a/packages/vue-querybuilder/src/components/ValueSelector.vue b/packages/vue-querybuilder/src/components/ValueSelector.vue
index 5e8f376..5a36a96 100644
--- a/packages/vue-querybuilder/src/components/ValueSelector.vue
+++ b/packages/vue-querybuilder/src/components/ValueSelector.vue
@@ -6,7 +6,7 @@ import {
   normalizeValueSelectorValue,
 } from '@react-querybuilder/core';
 import { computed } from 'vue';
-import type { ValueSelectorProps } from '../types/props.js';
+import type { VersatileSelectorProps } from '../types/props.js';
 
 /**
  * Default `<select>` component for every selector control — combinator, field, operator, value
@@ -14,10 +14,15 @@ import type { ValueSelectorProps } from '../types/props.js';
  *
  * Port of React Query Builder's `ValueSelector` (`ValueSelector.tsx`).
  */
-// See `ActionElement.vue` for why attribute fallthrough is disabled.
-defineOptions({ name: 'ValueSelector', inheritAttrs: false });
+defineOptions({ name: 'ValueSelector' });
 
-const props = defineProps<ValueSelectorProps>();
+// `VersatileSelectorProps`, not `ValueSelectorProps`: this component is the default for the
+// `combinatorSelector`, `fieldSelector`, `operatorSelector`, `valueSourceSelector`, and
+// `valueSelector` controls, so it receives the union of their prop sets (core's
+// `controlPropKeys`). Declaring the union is what keeps `rule`, `field`, `fieldData`,
+// `operator`, `ruleGroup`, and `rules` off the rendered `<select>` now that attribute
+// fallthrough is enabled. `controlProps.test.ts` gates the declaration against core.
+const props = defineProps<VersatileSelectorProps>();
 
 const val = computed(() => normalizeValueSelectorValue(props.value, props.multiple));
 
diff --git a/packages/vue-querybuilder/src/components/controlProps.test.ts b/packages/vue-querybuilder/src/components/controlProps.test.ts
new file mode 100644
index 0000000..32b4d61
--- /dev/null
+++ b/packages/vue-querybuilder/src/components/controlProps.test.ts
@@ -0,0 +1,148 @@
+import type { Field, RuleGroupTypeAny, ValueSources } from '@react-querybuilder/core';
+import { controlKeys, controlKind, controlPropKeys } from '@react-querybuilder/core';
+import { render } from '@testing-library/vue';
+import { describe, expect, it } from 'vitest';
+import type { ComponentOptions } from 'vue';
+import { defineComponent, h } from 'vue';
+import { defaultControlElements } from './defaultControlElements.js';
+import QueryBuilder from './QueryBuilder.vue';
+
+/**
+ * The gate for attribute fallthrough (no control sets `inheritAttrs: false`).
+ *
+ * Two halves, both keyed off core's `controlPropKeys` — the same data `react-querybuilder` gates
+ * its own props interfaces against, so neither half can drift from React unnoticed:
+ *
+ * 1. every default control **declares** every prop its control keys receive, and
+ * 2. the port **passes** nothing beyond those keys.
+ *
+ * Together they mean the `attrs` bag is empty except for what a consumer supplied, so
+ * fallthrough is safe. Break either one and a stray attribute lands on the rendered DOM, which
+ * React never emits.
+ *
+ * Excluded, and why: `dragHandle` (drag-and-drop is a documented non-goal),
+ * `ruleGroupHeaderElements`/`ruleGroupBodyElements` (internal here, not control elements), and
+ * `rule`/`ruleGroup` (their props carry the drag-and-drop set, and neither disables fallthrough).
+ */
+const gatedKeys = controlKeys.filter(
+  k =>
+    ![
+      'dragHandle',
+      'rule',
+      'ruleGroup',
+      'ruleGroupBodyElements',
+      'ruleGroupHeaderElements',
+    ].includes(k)
+);
+
+/**
+ * `ValueSelector` is the default for all five selector keys, so the props it may legitimately
+ * receive are the union of their sets — `VersatileSelectorProps`, which is what it declares.
+ * `valueEditor` forwards `field`/`fieldData`/`rule` into its nested selector exactly as React's
+ * `propsForValueSelector` does, so the `valueSelector` slot is gated against that union rather
+ * than against its own key alone.
+ */
+const versatileSelectorKeys = [
+  ...new Set(
+    [...controlKeys.filter(k => controlKind[k] === 'selector'), 'valueSelector'].flatMap(
+      k => (controlPropKeys as Record<string, readonly string[]>)[k] ?? []
+    )
+  ),
+];
+
+const propKeysOf = (key: string): readonly string[] =>
+  key === 'valueSelector'
+    ? versatileSelectorKeys
+    : (controlPropKeys as Record<string, readonly string[]>)[key];
+
+describe('control props', () => {
+  it.each(gatedKeys)('`%s`: the default control declares every prop it receives', key => {
+    const control = (defaultControlElements as unknown as Record<string, ComponentOptions>)[key];
+    const declared = Object.keys(control.props ?? {});
+    expect(propKeysOf(key).filter(k => !declared.includes(k))).toEqual([]);
+  });
+
+  it('passes no prop outside `controlPropKeys` to any control', () => {
+    const received: Record<string, Set<string>> = {};
+    const controlElements: Record<string, unknown> = {};
+    for (const key of gatedKeys) {
+      received[key] = new Set();
+      controlElements[key] = defineComponent({
+        name: `Probe_${key}`,
+        // The probe declares nothing, so every prop it is handed shows up in `attrs`.
+        inheritAttrs: false,
+        setup: (_props, { attrs }) => {
+          for (const k of Object.keys(attrs)) received[key].add(k);
+          return () => h('span');
+        },
+      });
+    }
+
+    const fields: Field[] = [
+      { name: 'f1', label: 'F1' },
+      { name: 'f2', label: 'F2', valueSources: ['value', 'field'] as ValueSources },
+      { name: 'sub', label: 'Sub', matchModes: true, subproperties: [{ name: 's1', label: 'S1' }] },
+      { name: 'sel', label: 'Sel', valueEditorType: 'select', values: [{ name: 'a', label: 'A' }] },
+    ];
+    const rules = [
+      { field: 'f1', operator: '=', value: 'v' },
+      { field: 'f2', operator: '=', value: 'v', valueSource: 'value' },
+      { field: 'sel', operator: '=', value: 'a' },
+      { field: 'sub', operator: '=', value: { combinator: 'and', rules: [] } },
+      { combinator: 'or', rules: [{ field: 'f1', operator: '=', value: 'x' }] },
+    ];
+    const flags = {
+      showCloneButtons: true,
+      showLockButtons: true,
+      showMuteButtons: true,
+      showShiftActions: true,
+      showNotToggle: true,
+      showUndoRedo: true,
+    };
+
+    // Every rendering path, since a control only reports what it is actually handed: the
+    // standard shape, combinators between rules, and independent combinators.
+    const queries: RuleGroupTypeAny[] = [
+      { combinator: 'and', rules } as RuleGroupTypeAny,
+      { rules: [rules[0], 'or', rules[1]] } as unknown as RuleGroupTypeAny,
+    ];
+    // `valueSelector` is only ever rendered *by* another control (`valueEditor`,
+    // `matchModeEditor`), so a probe in its slot never mounts while those are probes too. This
+    // pass restores the real ones so the `valueSelector` probe actually receives props.
+    const viaRealEditors = { ...controlElements };
+    delete viaRealEditors.valueEditor;
+    delete viaRealEditors.matchModeEditor;
+
+    for (const defaultQuery of queries) {
+      for (const showCombinatorsBetweenRules of [false, true]) {
+        render(QueryBuilder, {
+          props: { fields, defaultQuery, showCombinatorsBetweenRules, ...flags, controlElements },
+        });
+        render(QueryBuilder, {
+          props: {
+            fields,
+            defaultQuery,
+            showCombinatorsBetweenRules,
+            ...flags,
+            controlElements: viaRealEditors,
+          },
+        });
+      }
+    }
+
+    const strays = Object.fromEntries(
+      Object.entries(received)
+        .map(([key, got]) => [key, [...got].filter(k => !propKeysOf(key).includes(k)).toSorted()])
+        .filter(([, extra]) => (extra as string[]).length > 0)
+    );
+    expect(strays).toEqual({});
+    // Guard against the assertion above passing because nothing rendered. `actionElement` is the
+    // only key with no direct rendering path — it is a bulk override, always shadowed by a
+    // specific `*Action` key — so every other probe must have recorded at least one prop.
+    expect(
+      Object.entries(received)
+        .filter(([k, got]) => got.size === 0 && k !== 'actionElement')
+        .map(([k]) => k)
+    ).toEqual([]);
+  });
+});
diff --git a/packages/vue-querybuilder/src/composables/context.test.ts b/packages/vue-querybuilder/src/composables/context.test.ts
index a00ec0f..4088b0a 100644
--- a/packages/vue-querybuilder/src/composables/context.test.ts
+++ b/packages/vue-querybuilder/src/composables/context.test.ts
@@ -1,9 +1,12 @@
-import { defaultTranslations } from '@react-querybuilder/core';
+import {
+  controlKeys as coreControlKeys,
+  controlKind,
+  defaultTranslations,
+} from '@react-querybuilder/core';
 import { mount } from '@vue/test-utils';
 import { describe, expect, it } from 'vitest';
 import { defineComponent, h, nextTick, ref } from 'vue';
 import {
-  controlKeys,
   emptyValidationMap,
   mergeControlElements,
   mergeQueryBuilderConfig,
@@ -13,6 +16,15 @@ import {
   useQueryBuilderContext,
 } from './context.js';
 
+/**
+ * The control keys this port has. Core's list, minus the three controls the port does not
+ * implement — the same derivation `context.ts` makes, restated here rather than imported so the
+ * test does not simply agree with the implementation by construction.
+ */
+const controlKeys = coreControlKeys.filter(
+  k => k !== 'dragHandle' && k !== 'ruleGroupBodyElements' && k !== 'ruleGroupHeaderElements'
+);
+
 // oxlint-disable-next-line typescript/no-explicit-any
 const Stub = (name: string): any => defineComponent({ name, render: () => h('span', name) });
 
@@ -139,22 +151,24 @@ describe('mergeControlElements', () => {
     expect(merged.addRuleAction).toBe(nullComponent);
   });
 
-  it('applies actionElement in bulk to every *Action/*Actions key', () => {
+  // Bulk-override membership comes from core's `controlKind`, not from sniffing the key name.
+  // The two disagree about `shiftActions`/`undoRedoActions` (plural): neither takes the
+  // `actionElement` bulk override, matching React. Their buttons still render through the
+  // `actionElement` control, so an override reaches them that way.
+  it('applies actionElement in bulk to every action key', () => {
     const bulk = Stub('bulk');
     const merged = mergeControlElements({ actionElement: bulk }, {}, {} as never);
-    const actionKeys = controlKeys.filter(
-      k => (k.endsWith('Action') || k.endsWith('Actions')) && k !== 'actionElement'
-    );
+    const actionKeys = controlKeys.filter(k => controlKind[k] === 'action');
     expect(actionKeys.length).toBeGreaterThan(0);
     for (const key of actionKeys) {
       expect(merged[key]).toBe(bulk);
     }
   });
 
-  it('applies valueSelector in bulk to every *Selector key', () => {
+  it('applies valueSelector in bulk to every selector key', () => {
     const bulk = Stub('bulk');
     const merged = mergeControlElements({ valueSelector: bulk }, {}, {} as never);
-    const selectorKeys = controlKeys.filter(k => k.endsWith('Selector') && k !== 'valueSelector');
+    const selectorKeys = controlKeys.filter(k => controlKind[k] === 'selector');
     expect(selectorKeys.length).toBeGreaterThan(0);
     for (const key of selectorKeys) {
       expect(merged[key]).toBe(bulk);
@@ -176,6 +190,9 @@ describe('mergeControlElements', () => {
       'inlineCombinator',
       'notToggle',
       'matchModeEditor',
+      // Plural, and not bulk-override targets: `controlKind` says so, and React agrees.
+      'shiftActions',
+      'undoRedoActions',
     ] as const) {
       expect(merged[key]).not.toBe(bulk);
       expect(merged[key]).toBe(defaults[key]);
diff --git a/packages/vue-querybuilder/src/composables/context.ts b/packages/vue-querybuilder/src/composables/context.ts
index 798b723..37ed76e 100644
--- a/packages/vue-querybuilder/src/composables/context.ts
+++ b/packages/vue-querybuilder/src/composables/context.ts
@@ -5,6 +5,8 @@ import type {
   ValidationMap,
 } from '@react-querybuilder/core';
 import {
+  controlKeys as coreControlKeys,
+  controlKind,
   defaultTranslations,
   mergeAnyTranslations,
   mergeClassnames,
@@ -81,45 +83,19 @@ export const useQueryBuilderContext = <
     ? (inject(contextKey, undefined) as ComputedRef<QueryBuilderContextProps<F, O>> | undefined)
     : undefined;
 
-/**
- * A control element key that is overridden in bulk by `actionElement`.
- */
-const isActionKey = (key: string): boolean => key.endsWith('Action') || key.endsWith('Actions');
-
-/**
- * A control element key that is overridden in bulk by `valueSelector`.
- */
-const isSelectorKey = (key: string): boolean => key.endsWith('Selector');
-
 /**
  * Every key of {@link Controls}, in a stable order.
+ *
+ * Derived from core's `controlKeys` rather than restated, so a control added upstream cannot be
+ * missed here. The three exclusions are the controls this port does not have: `dragHandle`
+ * (drag-and-drop is a documented non-goal) and the header/body element lists (internal
+ * components here, not control elements).
+ *
+ * Module-private. Consumers who need the list get core's, which the package re-exports.
  */
-export const controlKeys = [
-  'actionElement',
-  'addGroupAction',
-  'addRuleAction',
-  'cloneGroupAction',
-  'cloneRuleAction',
-  'combinatorSelector',
-  'fieldSelector',
-  'inlineCombinator',
-  'lockGroupAction',
-  'lockRuleAction',
-  'matchModeEditor',
-  'muteGroupAction',
-  'muteRuleAction',
-  'notToggle',
-  'operatorSelector',
-  'removeGroupAction',
-  'removeRuleAction',
-  'rule',
-  'ruleGroup',
-  'shiftActions',
-  'undoRedoActions',
-  'valueEditor',
-  'valueSelector',
-  'valueSourceSelector',
-] as const satisfies readonly (keyof Controls<FullField, string>)[];
+const controlKeys = coreControlKeys.filter(
+  k => k !== 'dragHandle' && k !== 'ruleGroupBodyElements' && k !== 'ruleGroupHeaderElements'
+) as unknown as readonly (keyof Controls<FullField, string>)[];
 
 /**
  * The wrapped component for a named slot, or `undefined` if that slot is absent.
@@ -178,13 +154,13 @@ export const mergeControlElements = <F extends FullField, O extends string>(
       if (comp) return comp;
 
       const bulkSlot =
-        (isActionKey(key) ? slotFor(sl, 'actionElement') : undefined) ??
-        (isSelectorKey(key) ? slotFor(sl, 'valueSelector') : undefined);
+        (controlKind[key] === 'action' ? slotFor(sl, 'actionElement') : undefined) ??
+        (controlKind[key] === 'selector' ? slotFor(sl, 'valueSelector') : undefined);
       if (bulkSlot) return bulkSlot;
 
       return (
-        (isActionKey(key) ? ce.actionElement : undefined) ??
-        (isSelectorKey(key) ? ce.valueSelector : undefined)
+        (controlKind[key] === 'action' ? ce.actionElement : undefined) ??
+        (controlKind[key] === 'selector' ? ce.valueSelector : undefined)
       );
     };
 
diff --git a/packages/vue-querybuilder/src/composables/useQueryBuilder.test.ts b/packages/vue-querybuilder/src/composables/useQueryBuilder.test.ts
index f034eb1..362411b 100644
--- a/packages/vue-querybuilder/src/composables/useQueryBuilder.test.ts
+++ b/packages/vue-querybuilder/src/composables/useQueryBuilder.test.ts
@@ -23,6 +23,27 @@ describe('useQueryBuilder', () => {
       expect(result.query.value).toBe(manager.getQuery());
     });
 
+    // Gate for the proxy-safe `QueryManager` (core 8.23.0). Vue Test Utils wraps mount props in
+    // `reactive`, so a consumer hits this by accident rather than by choice. Before the bump the
+    // port had to `toRaw` the manager; without that, every call threw
+    // `Cannot read private member #past`.
+    it('drives a manager wrapped in `reactive()`', () => {
+      const manager = reactive(
+        new QueryManager(flatQuery, { fields: testFields, history: true })
+      ) as unknown as QueryManager;
+      const { result } = runInScope(() =>
+        useQueryBuilder(baseProps({ manager: manager as never, defaultQuery: undefined }))
+      );
+      result.actions.onRuleRemove([0]);
+      expect(result.manager.getQuery().rules).toHaveLength(1);
+      expect(result.manager.canUndo()).toBe(true);
+      result.manager.undo();
+      expect(result.manager.getQuery().rules).toHaveLength(2);
+      // The state bag is a non-enumerable own property, so it stays out of `Object.keys`,
+      // spread, and `JSON.stringify`.
+      expect(Object.keys(manager)).toEqual(Object.keys(new QueryManager()));
+    });
+
     it('seeds from defaultQuery', () => {
       const { result } = runInScope(() => useQueryBuilder(baseProps({ defaultQuery: flatQuery })));
       expect(result.query.value.rules).toHaveLength(2);
diff --git a/packages/vue-querybuilder/src/composables/useQueryBuilder.ts b/packages/vue-querybuilder/src/composables/useQueryBuilder.ts
index 6078e10..fef2017 100644
--- a/packages/vue-querybuilder/src/composables/useQueryBuilder.ts
+++ b/packages/vue-querybuilder/src/composables/useQueryBuilder.ts
@@ -290,13 +290,11 @@ export const useQueryBuilder = <
     };
   };
 
+  // No `toRaw` on the manager: as of `@react-querybuilder/core` 8.23.0 its state lives in a
+  // non-enumerable symbol-keyed own property, which reads correctly through a reactive `Proxy`,
+  // and that property is flagged `__v_skip` so `reactive()` will not deep-proxy it either.
   const manager =
-    (toRaw(initialProps.manager) as QueryManager<
-      RuleGroupTypeAny,
-      F,
-      FullOperator,
-      FullCombinator
-    >) ??
+    (initialProps.manager as QueryManager<RuleGroupTypeAny, F, FullOperator, FullCombinator>) ??
     new QueryManager<RuleGroupTypeAny, F, O, FullCombinator>(undefined, buildManagerOptions());
 
   if (!initialProps.manager) {
@@ -486,7 +484,7 @@ export const useQueryBuilder = <
       next => {
         if (valuesEqual(next, appliedSignature)) return;
         appliedSignature = next;
-        toRaw(manager).reconfigure(buildManagerOptions());
+        manager.reconfigure(buildManagerOptions());
       },
       { flush: 'post' }
     );
diff --git a/packages/vue-querybuilder/src/internal/RuleComponents.vue b/packages/vue-querybuilder/src/internal/RuleComponents.vue
index fac169b..8135945 100644
--- a/packages/vue-querybuilder/src/internal/RuleComponents.vue
+++ b/packages/vue-querybuilder/src/internal/RuleComponents.vue
@@ -31,7 +31,11 @@ const rule = computed(() => ruleProps.value.rule);
 const translations = computed(() => ruleProps.value.translations);
 const controls = computed(() => schema.value.controls);
 
-/** The props every subcomponent of a rule receives. */
+/**
+ * The props every subcomponent of a rule receives. Deliberately the intersection of core's
+ * `controlPropKeys` entries: `rule` is bound only on the controls whose prop lists include it,
+ * so nothing falls through to the DOM now that the default controls inherit attributes.
+ */
 const common = computed(() => ({
   level: ruleProps.value.path.length,
   path: ruleProps.value.path,
@@ -39,7 +43,6 @@ const common = computed(() => ({
   context: ruleProps.value.context,
   validation: parts.ctx.validationResult,
   schema: schema.value,
-  rule: rule.value,
 }));
 
 const shiftTitles = computed(() =>
@@ -89,6 +92,7 @@ const fieldIsSelected = computed(
     v-if="parts.showFieldSelector"
     v-bind="common"
     :testID="TestID.fields"
+    :rule="rule"
     :options="schema.fields"
     :title="translations.fields?.title"
     :value="rule.field"
@@ -101,6 +105,7 @@ const fieldIsSelected = computed(
       v-if="subQueryParts"
       v-bind="common"
       :testID="TestID.matchModeEditor"
+      :rule="rule"
       :field="rule.field"
       :fieldData="parts.fieldData"
       :title="translations.matchMode?.title"
@@ -115,6 +120,7 @@ const fieldIsSelected = computed(
         :is="controls.operatorSelector"
         v-bind="common"
         :testID="TestID.operators"
+        :rule="rule"
         :field="rule.field"
         :fieldData="parts.fieldData"
         :title="translations.operators?.title"
@@ -128,6 +134,7 @@ const fieldIsSelected = computed(
           v-if="parts.showValueSourceSelector"
           v-bind="common"
           :testID="TestID.valueSourceSelector"
+          :rule="rule"
           :field="rule.field"
           :fieldData="parts.fieldData"
           :title="translations.valueSourceSelector?.title"
@@ -139,6 +146,7 @@ const fieldIsSelected = computed(
           :is="controls.valueEditor"
           v-bind="common"
           :testID="TestID.valueEditor"
+          :rule="rule"
           :field="rule.field"
           :fieldData="parts.fieldData"
           :title="translations.value?.title"
diff --git a/packages/vue-querybuilder/src/types/types.test-d.ts b/packages/vue-querybuilder/src/types/types.test-d.ts
index fcba005..3e2b4c4 100644
--- a/packages/vue-querybuilder/src/types/types.test-d.ts
+++ b/packages/vue-querybuilder/src/types/types.test-d.ts
@@ -2,7 +2,9 @@
  * Type-level tests. Not executed by Vitest; compiled by `vue-tsc`, which is where the assertions
  * below are enforced. Any error here fails `bun run check`.
  */
+import type { controlPropKeys } from '@react-querybuilder/core';
 import type {
+  ControlKey,
   FullCombinator,
   FullField,
   FullOperator,
@@ -17,6 +19,7 @@ import type {
   ActionProps,
   ControlComponent,
   ControlElementsProp,
+  ControlPropsMap,
   ControlSlots,
   Controls,
   LabelNode,
@@ -201,3 +204,26 @@ assertType<ControlSlots<FullField, string> | undefined>(stdProps.slots);
 assertType<RuleType>(null as unknown as RuleTypeOf<RuleGroupType>);
 assertType<RuleType>(null as unknown as RuleTypeOf<RuleGroupTypeIC>);
 // #endregion
+
+// #region Control prop keys
+// The compile-time half of the fallthrough gate (see `components/controlProps.test.ts` for the
+// runtime half): every prop core says a control receives must exist on the port's props type for
+// that control. Drift shows up here as an error rather than as a stray DOM attribute.
+//
+// `rule`, `ruleGroup`, `dragHandle`, and the header/body element keys are excluded — see the
+// comment in `controlProps.test.ts`.
+type GatedControlKey = Exclude<
+  ControlKey,
+  'dragHandle' | 'rule' | 'ruleGroup' | 'ruleGroupBodyElements' | 'ruleGroupHeaderElements'
+>;
+
+type UndeclaredPropKeys<K extends GatedControlKey> = Exclude<
+  (typeof controlPropKeys)[K][number],
+  keyof ControlPropsMap<FullField, string>[K]
+>;
+
+type AssertNever<T extends never> = T;
+type _NoUndeclaredControlProps = AssertNever<
+  { [K in GatedControlKey]: UndeclaredPropKeys<K> }[GatedControlKey]
+>;
+// #endregion