@react-querybuilder/core 8.22.5 → 8.23.1

package/dist/react-querybuilder_core.legacy-esm.js

@@ -1,5 +1,646 @@
 import { numericQuantity, numericRegex as numericRegex$1 } from "numeric-quantity";
-import { current, freeze, isDraft, produce } from "immer";
+import { Immer, current, freeze, isDraft, produce, setAutoFreeze as setAutoFreeze$1 } from "immer";
+//#region src/controlPropKeys.ts
+/**
+* Runtime data describing the set of query builder controls and the props each one receives.
+*
+* These live in `@react-querybuilder/core` (not `react-querybuilder`) so that non-React ports
+* can consume them without a React dependency.
+*
+* Nothing here can drift from the React implementation unnoticed:
+* `react-querybuilder`'s `types/controlPropKeys.test.ts` gates {@link controlKeys} against
+* `defaultControlElements` and `ControlElementsProp`, and every entry of
+* {@link controlPropKeys} against the corresponding props interface—both at runtime and at
+* compile time, in both directions.
+*/
+/**
+* The name of every query builder control, alphabetized.
+*
+* @group Props
+*/
+const controlKeys = [
+	"actionElement",
+	"addGroupAction",
+	"addRuleAction",
+	"cloneGroupAction",
+	"cloneRuleAction",
+	"combinatorSelector",
+	"dragHandle",
+	"fieldSelector",
+	"inlineCombinator",
+	"lockGroupAction",
+	"lockRuleAction",
+	"matchModeEditor",
+	"muteGroupAction",
+	"muteRuleAction",
+	"notToggle",
+	"operatorSelector",
+	"removeGroupAction",
+	"removeRuleAction",
+	"rule",
+	"ruleGroup",
+	"ruleGroupBodyElements",
+	"ruleGroupHeaderElements",
+	"shiftActions",
+	"undoRedoActions",
+	"valueEditor",
+	"valueSelector",
+	"valueSourceSelector"
+];
+/**
+* The full set of prop names each default control receives. Ports can use this to declare
+* every prop explicitly instead of relying on fall-through/attribute inheritance.
+*
+* Each array is the complete, alphabetized key set of the control's props interface in
+* `react-querybuilder`. The lists are written out in full rather than composed from shared
+* bases because `--isolatedDeclarations` cannot infer array types built with spreads. A
+* compile-time gate in `react-querybuilder` (`types/controlPropKeys.test.ts`) fails the build
+* if any list drifts from its interface in either direction.
+*
+* @group Props
+*/
+const controlPropKeys = {
+	actionElement: [
+		"className",
+		"context",
+		"disabled",
+		"disabledTranslation",
+		"handleOnClick",
+		"label",
+		"level",
+		"path",
+		"ruleOrGroup",
+		"rules",
+		"schema",
+		"testID",
+		"title",
+		"validation"
+	],
+	addGroupAction: [
+		"className",
+		"context",
+		"disabled",
+		"disabledTranslation",
+		"handleOnClick",
+		"label",
+		"level",
+		"path",
+		"ruleOrGroup",
+		"rules",
+		"schema",
+		"testID",
+		"title",
+		"validation"
+	],
+	addRuleAction: [
+		"className",
+		"context",
+		"disabled",
+		"disabledTranslation",
+		"handleOnClick",
+		"label",
+		"level",
+		"path",
+		"ruleOrGroup",
+		"rules",
+		"schema",
+		"testID",
+		"title",
+		"validation"
+	],
+	cloneGroupAction: [
+		"className",
+		"context",
+		"disabled",
+		"disabledTranslation",
+		"handleOnClick",
+		"label",
+		"level",
+		"path",
+		"ruleOrGroup",
+		"rules",
+		"schema",
+		"testID",
+		"title",
+		"validation"
+	],
+	cloneRuleAction: [
+		"className",
+		"context",
+		"disabled",
+		"disabledTranslation",
+		"handleOnClick",
+		"label",
+		"level",
+		"path",
+		"ruleOrGroup",
+		"rules",
+		"schema",
+		"testID",
+		"title",
+		"validation"
+	],
+	combinatorSelector: [
+		"className",
+		"context",
+		"disabled",
+		"handleOnChange",
+		"level",
+		"options",
+		"path",
+		"ruleGroup",
+		"rules",
+		"schema",
+		"testID",
+		"title",
+		"validation",
+		"value"
+	],
+	dragHandle: [
+		"className",
+		"context",
+		"disabled",
+		"dragHandleAttributes",
+		"label",
+		"level",
+		"path",
+		"ruleOrGroup",
+		"schema",
+		"testID",
+		"title",
+		"validation"
+	],
+	fieldSelector: [
+		"className",
+		"context",
+		"disabled",
+		"handleOnChange",
+		"level",
+		"operator",
+		"options",
+		"path",
+		"rule",
+		"schema",
+		"testID",
+		"title",
+		"validation",
+		"value"
+	],
+	inlineCombinator: [
+		"className",
+		"component",
+		"context",
+		"disabled",
+		"handleOnChange",
+		"level",
+		"options",
+		"path",
+		"ruleGroup",
+		"rules",
+		"schema",
+		"testID",
+		"title",
+		"validation",
+		"value"
+	],
+	lockGroupAction: [
+		"className",
+		"context",
+		"disabled",
+		"disabledTranslation",
+		"handleOnClick",
+		"label",
+		"level",
+		"path",
+		"ruleOrGroup",
+		"rules",
+		"schema",
+		"testID",
+		"title",
+		"validation"
+	],
+	lockRuleAction: [
+		"className",
+		"context",
+		"disabled",
+		"disabledTranslation",
+		"handleOnClick",
+		"label",
+		"level",
+		"path",
+		"ruleOrGroup",
+		"rules",
+		"schema",
+		"testID",
+		"title",
+		"validation"
+	],
+	matchModeEditor: [
+		"className",
+		"classNames",
+		"context",
+		"disabled",
+		"field",
+		"fieldData",
+		"handleOnChange",
+		"level",
+		"match",
+		"numericEditorComponent",
+		"options",
+		"path",
+		"rule",
+		"schema",
+		"selectorComponent",
+		"testID",
+		"thresholdPlaceholder",
+		"title",
+		"validation",
+		"value"
+	],
+	muteGroupAction: [
+		"className",
+		"context",
+		"disabled",
+		"disabledTranslation",
+		"handleOnClick",
+		"label",
+		"level",
+		"path",
+		"ruleOrGroup",
+		"rules",
+		"schema",
+		"testID",
+		"title",
+		"validation"
+	],
+	muteRuleAction: [
+		"className",
+		"context",
+		"disabled",
+		"disabledTranslation",
+		"handleOnClick",
+		"label",
+		"level",
+		"path",
+		"ruleOrGroup",
+		"rules",
+		"schema",
+		"testID",
+		"title",
+		"validation"
+	],
+	notToggle: [
+		"checked",
+		"className",
+		"context",
+		"disabled",
+		"handleOnChange",
+		"label",
+		"level",
+		"path",
+		"ruleGroup",
+		"schema",
+		"testID",
+		"title",
+		"validation"
+	],
+	operatorSelector: [
+		"className",
+		"context",
+		"disabled",
+		"field",
+		"fieldData",
+		"handleOnChange",
+		"level",
+		"options",
+		"path",
+		"rule",
+		"schema",
+		"testID",
+		"title",
+		"validation",
+		"value"
+	],
+	removeGroupAction: [
+		"className",
+		"context",
+		"disabled",
+		"disabledTranslation",
+		"handleOnClick",
+		"label",
+		"level",
+		"path",
+		"ruleOrGroup",
+		"rules",
+		"schema",
+		"testID",
+		"title",
+		"validation"
+	],
+	removeRuleAction: [
+		"className",
+		"context",
+		"disabled",
+		"disabledTranslation",
+		"handleOnClick",
+		"label",
+		"level",
+		"path",
+		"ruleOrGroup",
+		"rules",
+		"schema",
+		"testID",
+		"title",
+		"validation"
+	],
+	rule: [
+		"actions",
+		"context",
+		"disabled",
+		"dndRef",
+		"dragHandleAttributes",
+		"dragMonitorId",
+		"dragRef",
+		"dropEffect",
+		"dropMonitorId",
+		"dropNotAllowed",
+		"field",
+		"groupItems",
+		"id",
+		"isDragging",
+		"isOver",
+		"operator",
+		"parentDisabled",
+		"parentMuted",
+		"path",
+		"rule",
+		"schema",
+		"shiftDownDisabled",
+		"shiftUpDisabled",
+		"translations",
+		"value",
+		"valueSource"
+	],
+	ruleGroup: [
+		"actions",
+		"combinator",
+		"context",
+		"disabled",
+		"dragHandleAttributes",
+		"dragMonitorId",
+		"dragRef",
+		"dropEffect",
+		"dropMonitorId",
+		"dropNotAllowed",
+		"dropRef",
+		"groupItems",
+		"id",
+		"isDragging",
+		"isOver",
+		"not",
+		"parentDisabled",
+		"parentMuted",
+		"path",
+		"previewRef",
+		"ruleGroup",
+		"rules",
+		"schema",
+		"shiftDownDisabled",
+		"shiftUpDisabled",
+		"translations"
+	],
+	ruleGroupBodyElements: [
+		"accessibleDescription",
+		"actions",
+		"addGroup",
+		"addRule",
+		"classNames",
+		"cloneGroup",
+		"combinator",
+		"context",
+		"disabled",
+		"dragHandleAttributes",
+		"dragMonitorId",
+		"dragRef",
+		"dropEffect",
+		"dropMonitorId",
+		"dropNotAllowed",
+		"dropRef",
+		"groupItems",
+		"id",
+		"isDragging",
+		"isOver",
+		"muted",
+		"not",
+		"onCombinatorChange",
+		"onGroupAdd",
+		"onIndependentCombinatorChange",
+		"onNotToggleChange",
+		"outerClassName",
+		"parentDisabled",
+		"parentMuted",
+		"path",
+		"pathsMemo",
+		"previewRef",
+		"removeGroup",
+		"ruleGroup",
+		"rules",
+		"schema",
+		"shiftDownDisabled",
+		"shiftGroupDown",
+		"shiftGroupUp",
+		"shiftUpDisabled",
+		"toggleLockGroup",
+		"toggleMuteGroup",
+		"translations",
+		"validationClassName",
+		"validationResult"
+	],
+	ruleGroupHeaderElements: [
+		"accessibleDescription",
+		"actions",
+		"addGroup",
+		"addRule",
+		"classNames",
+		"cloneGroup",
+		"combinator",
+		"context",
+		"disabled",
+		"dragHandleAttributes",
+		"dragMonitorId",
+		"dragRef",
+		"dropEffect",
+		"dropMonitorId",
+		"dropNotAllowed",
+		"dropRef",
+		"groupItems",
+		"id",
+		"isDragging",
+		"isOver",
+		"muted",
+		"not",
+		"onCombinatorChange",
+		"onGroupAdd",
+		"onIndependentCombinatorChange",
+		"onNotToggleChange",
+		"outerClassName",
+		"parentDisabled",
+		"parentMuted",
+		"path",
+		"pathsMemo",
+		"previewRef",
+		"removeGroup",
+		"ruleGroup",
+		"rules",
+		"schema",
+		"shiftDownDisabled",
+		"shiftGroupDown",
+		"shiftGroupUp",
+		"shiftUpDisabled",
+		"toggleLockGroup",
+		"toggleMuteGroup",
+		"translations",
+		"validationClassName",
+		"validationResult"
+	],
+	shiftActions: [
+		"className",
+		"context",
+		"disabled",
+		"labels",
+		"level",
+		"path",
+		"ruleOrGroup",
+		"schema",
+		"shiftDown",
+		"shiftDownDisabled",
+		"shiftUp",
+		"shiftUpDisabled",
+		"testID",
+		"title",
+		"titles",
+		"validation"
+	],
+	undoRedoActions: [
+		"className",
+		"classNames",
+		"context",
+		"disabled",
+		"labels",
+		"level",
+		"path",
+		"ruleOrGroup",
+		"schema",
+		"testID",
+		"title",
+		"titles",
+		"validation"
+	],
+	valueEditor: [
+		"className",
+		"context",
+		"disabled",
+		"field",
+		"fieldData",
+		"handleOnChange",
+		"inputType",
+		"level",
+		"listsAsArrays",
+		"operator",
+		"parseNumbers",
+		"path",
+		"rule",
+		"schema",
+		"selectorComponent",
+		"separator",
+		"skipHook",
+		"testID",
+		"title",
+		"type",
+		"validation",
+		"value",
+		"valueSource",
+		"values"
+	],
+	valueSelector: [
+		"className",
+		"context",
+		"disabled",
+		"handleOnChange",
+		"level",
+		"listsAsArrays",
+		"multiple",
+		"options",
+		"path",
+		"schema",
+		"testID",
+		"title",
+		"validation",
+		"value"
+	],
+	valueSourceSelector: [
+		"className",
+		"context",
+		"disabled",
+		"field",
+		"fieldData",
+		"handleOnChange",
+		"level",
+		"options",
+		"path",
+		"rule",
+		"schema",
+		"testID",
+		"title",
+		"validation",
+		"value"
+	]
+};
+/**
+* Which bulk override, if any, applies to each control: `"action"` for controls that a supplied
+* `actionElement` replaces, `"selector"` for controls that a supplied `valueSelector` replaces,
+* and `null` for controls that neither replaces.
+*
+* `actionElement` and `valueSelector` are themselves `null`—they are the _source_ of a bulk
+* override, not a target of one.
+*
+* Replaces name-suffix sniffing (`key.endsWith('Action')`), which would silently misclassify a
+* future control named e.g. `pathSelector`, and which disagrees between implementations about
+* whether `shiftActions`/`undoRedoActions` (plural) match. They do not: neither receives the
+* `actionElement` bulk override.
+*
+* @group Props
+*/
+const controlKind = {
+	actionElement: null,
+	addGroupAction: "action",
+	addRuleAction: "action",
+	cloneGroupAction: "action",
+	cloneRuleAction: "action",
+	combinatorSelector: "selector",
+	dragHandle: null,
+	fieldSelector: "selector",
+	inlineCombinator: null,
+	lockGroupAction: "action",
+	lockRuleAction: "action",
+	matchModeEditor: null,
+	muteGroupAction: "action",
+	muteRuleAction: "action",
+	notToggle: null,
+	operatorSelector: "selector",
+	removeGroupAction: "action",
+	removeRuleAction: "action",
+	rule: null,
+	ruleGroup: null,
+	ruleGroupBodyElements: null,
+	ruleGroupHeaderElements: null,
+	shiftActions: null,
+	undoRedoActions: null,
+	valueEditor: null,
+	valueSelector: null,
+	valueSourceSelector: "selector"
+};
+//#endregion
 //#region src/defaults.ts
 /**
 * @group Defaults
@@ -648,6 +1289,31 @@ const defaultMaxHistory = 50;
 */
 const defaultCoalesceMs = 500;
 //#endregion
+//#region src/utils/abortReasons.ts
+/**
+* Abort reasons that {@link QueryManager}'s `strict` mode treats as errors. The remaining
+* reasons—`"same-location"` and `"no-change"`—describe valid operations that had nothing to do,
+* so they are reported to `onInvalidTarget` but never throw.
+*
+* Declared apart from `QueryManager` so the `@react-querybuilder/core/derivations` entry point can
+* export it without putting the manager in its module graph.
+*
+* @group Query Tools
+*/
+const strictAbortReasons = [
+	"target-not-found",
+	"parent-not-found",
+	"parent-not-a-group",
+	"destination-not-found",
+	"root-not-allowed",
+	"not-a-combinator-slot",
+	"target-disabled",
+	"parent-disabled",
+	"max-levels-exceeded"
+];
+/** @internal */
+const strictAbortReasonSet = new Set(strictAbortReasons);
+//#endregion
 //#region src/utils/arrayUtils.ts
 /**
 * Splits a string by a given character (see {@link defaultJoinChar}). Escaped characters
@@ -750,7 +1416,100 @@ const isRuleGroupType = (rg) => isRuleGroup(rg) && typeof rg.combinator === "str
 */
 const isRuleGroupTypeIC = (rg) => isRuleGroup(rg) && rg.combinator === void 0;
 //#endregion
-//#region \0@oxc-project+runtime@0.142.0/helpers/esm/typeof.js
+//#region src/utils/signature.ts
+/**
+* Signature returned when a change alters the _shape_ of the query—rules or groups added,
+* removed, moved, or reordered—rather than the properties of a single node. Structural changes
+* never coalesce with each other, so each one produces its own history entry.
+*/
+const structuralSignature = "~structural";
+/**
+* Signature returned when two queries differ by reference only, with no observable difference
+* in their properties.
+*/
+const unchangedSignature = "";
+/**
+* Returns the list of property names that differ between two nodes, ignoring `rules` (which is
+* compared structurally by the caller).
+*/
+const changedProps = (prev, next) => {
+	const keys = /* @__PURE__ */ new Set([...Object.keys(prev), ...Object.keys(next)]);
+	keys.delete("rules");
+	const changed = [];
+	for (const key of keys) if (!Object.is(prev[key], next[key])) changed.push(key);
+	return changed.toSorted();
+};
+const signatureOfNode = (prev, next, parentId, index) => {
+	var _next$id3;
+	if (prev === next) return "";
+	if (typeof prev === "string" || typeof next === "string") return typeof prev === typeof next ? `${parentId}:combinator[${index}]` : structuralSignature;
+	const prevIsGroup = isRuleGroup(prev);
+	const nextIsGroup = isRuleGroup(next);
+	if (prevIsGroup !== nextIsGroup) return structuralSignature;
+	if (!prevIsGroup || !nextIsGroup) {
+		var _next$id;
+		const props = changedProps(prev, next);
+		return props.length === 0 ? "" : `${(_next$id = next.id) !== null && _next$id !== void 0 ? _next$id : ""}:${props.join(",")}`;
+	}
+	if (prev.rules.length !== next.rules.length) return structuralSignature;
+	const ownProps = changedProps(prev, next);
+	let changedIndex = -1;
+	for (const [i, prevRule] of prev.rules.entries()) if (prevRule !== next.rules[i]) {
+		if (changedIndex !== -1) return structuralSignature;
+		changedIndex = i;
+	}
+	if (changedIndex === -1) {
+		var _next$id2;
+		return ownProps.length === 0 ? "" : `${(_next$id2 = next.id) !== null && _next$id2 !== void 0 ? _next$id2 : ""}:${ownProps.join(",")}`;
+	}
+	if (ownProps.length > 0) return structuralSignature;
+	return signatureOfNode(prev.rules[changedIndex], next.rules[changedIndex], (_next$id3 = next.id) !== null && _next$id3 !== void 0 ? _next$id3 : "", changedIndex);
+};
+/**
+* Describes _what changed_ between two versions of a query as a short string, so that
+* consecutive edits to the same property of the same rule (e.g. typing in a value editor) can
+* be recognized and coalesced into a single history entry.
+*
+* Returns {@link structuralSignature} for changes to the shape of the query, {@link unchangedSignature} when the
+* two queries differ by reference only, and `"<id>:<props>"` otherwise.
+*
+* The walk prunes on reference equality, so it costs O(depth) rather than O(size) for the
+* single-node edits that make up the overwhelming majority of changes.
+*
+* Note that this relies on the structural sharing that Immer—and therefore every query
+* produced by RQB's own update functions—guarantees: nodes that did not change keep their
+* identity. A query that has been wholly rebuilt (deep-cloned, round-tripped through JSON,
+* re-parsed from a string) shares no identity with its predecessor, so it is reported as
+* {@link structuralSignature} and will not coalesce. That is a graceful degradation—every change simply
+* gets its own history entry—but controlled components that clone the query on every change
+* will not benefit from coalescing.
+*/
+const signatureOf = (prev, next) => signatureOfNode(prev, next, "", -1);
+//#endregion
+//#region src/utils/coalesce.ts
+/**
+* Determines whether a change should be absorbed into the current history entry instead of
+* pushing a new one. This is the exact rule {@link QueryManager} applies when recording history,
+* exposed so non-React implementations can manage their own history stacks without
+* reimplementing (and drifting from) the semantics.
+*
+* A change coalesces only when all three hold:
+* - the change is not structural (rules/groups added, removed, moved, or reordered)
+* - its signature matches the previously recorded signature
+* - it occurred within `coalesceMs` of the previous recording
+*
+* Note that {@link unchangedSignature} is not handled here. A change with no observable
+* difference is never recorded at all, which is a separate decision made before this check.
+*
+* @param prevSig Signature of the previously recorded change, or `undefined` if there is none.
+* @param nextSig Signature of the change being recorded, from {@link signatureOf}.
+* @param prevAt Timestamp of the previous recording.
+* @param now Timestamp of the change being recorded.
+* @param coalesceMs Coalescing window in milliseconds.
+*/
+const shouldCoalesce = (prevSig, nextSig, prevAt, now, coalesceMs = 500) => nextSig !== "~structural" && nextSig === prevSig && now >= prevAt && now - prevAt < coalesceMs;
+//#endregion
+//#region \0@oxc-project+runtime@0.144.0/helpers/esm/typeof.js
 function _typeof(o) {
 	"@babel/helpers - typeof";
 	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
@@ -760,7 +1519,7 @@ function _typeof(o) {
 	}, _typeof(o);
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.142.0/helpers/esm/toPrimitive.js
+//#region \0@oxc-project+runtime@0.144.0/helpers/esm/toPrimitive.js
 function toPrimitive(t, r) {
 	if ("object" != _typeof(t) || !t) return t;
 	var e = t[Symbol.toPrimitive];
@@ -772,13 +1531,13 @@ function toPrimitive(t, r) {
 	return ("string" === r ? String : Number)(t);
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.142.0/helpers/esm/toPropertyKey.js
+//#region \0@oxc-project+runtime@0.144.0/helpers/esm/toPropertyKey.js
 function toPropertyKey(t) {
 	var i = toPrimitive(t, "string");
 	return "symbol" == _typeof(i) ? i : i + "";
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.142.0/helpers/esm/defineProperty.js
+//#region \0@oxc-project+runtime@0.144.0/helpers/esm/defineProperty.js
 function _defineProperty(e, r, t) {
 	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
 		value: t,
@@ -788,7 +1547,7 @@ function _defineProperty(e, r, t) {
 	}) : e[r] = t, e;
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.142.0/helpers/esm/objectSpread2.js
+//#region \0@oxc-project+runtime@0.144.0/helpers/esm/objectSpread2.js
 function ownKeys(e, r) {
 	var t = Object.keys(e);
 	if (Object.getOwnPropertySymbols) {
@@ -811,7 +1570,7 @@ function _objectSpread2(e) {
 	return e;
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.142.0/helpers/esm/objectWithoutPropertiesLoose.js
+//#region \0@oxc-project+runtime@0.144.0/helpers/esm/objectWithoutPropertiesLoose.js
 function _objectWithoutPropertiesLoose(r, e) {
 	if (null == r) return {};
 	var t = {};
@@ -822,7 +1581,7 @@ function _objectWithoutPropertiesLoose(r, e) {
 	return t;
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.142.0/helpers/esm/objectWithoutProperties.js
+//#region \0@oxc-project+runtime@0.144.0/helpers/esm/objectWithoutProperties.js
 function _objectWithoutProperties(e, t) {
 	if (null == e) return {};
 	var o, r, i = _objectWithoutPropertiesLoose(e, t);
@@ -1351,6 +2110,20 @@ const uniqOptList = (originalArray) => {
 	if (isFlexibleOptionGroupArray(originalArray)) return uniqOptGroups(originalArray);
 	return uniqByIdentifier(originalArray.map((o) => toFullOption(o)));
 };
+/**
+* Normalizes any accepted option list shape—array, option groups, or a record—into a
+* `FullOptionList`, applying `baseOption` properties and (when `autoSelectOption` is `false`)
+* a leading placeholder option. Also returns the flattened lookup map and the option that
+* should be selected by default.
+*
+* Note: `labelMap` overrides only apply to array/option group input (where string options are
+* expanded); record input derives labels from the record values themselves.
+*
+* This is the same normalization `<QueryBuilder />` applies to `fields`, `operators`,
+* `combinators`, and value lists, so a non-React implementation resolves options identically.
+*
+* @group Option Lists
+*/
 const prepareOptionList = (props) => {
 	// v8 ignore next
 	const { optionList: optionListPropOriginal, baseOption = {}, labelMap = {}, placeholder: { placeholderName = "~", placeholderLabel = defaultPlaceholderLabel, placeholderGroupLabel = defaultPlaceholderLabel } = {}, autoSelectOption = true } = props;
@@ -4628,8 +5401,10 @@ const defaultRuleProcessorParameterized = (rule, opts, meta) => {
 		return finalize(`${qPre}${rule.field}${qPost} ${sqlOperator} ${paramPrefix}${firstParamName} and ${paramPrefix}${secondParamName}`);
 	}
 	let paramValue = rule.value;
-	if (typeof rule.value === "string") if (shouldRenderAsNumber(rule.value, parseNumbers)) paramValue = parseNumber(rule.value, { parseNumbers });
-	else paramValue = /^'.*'$/g.test(value) ? value.replaceAll(/(^'|'$)/g, "") : /* v8 ignore next -- @preserve */ value;
+	if (typeof rule.value === "string") {
+		if (shouldRenderAsNumber(rule.value, parseNumbers)) paramValue = parseNumber(rule.value, { parseNumbers });
+		else paramValue = /^'.*'$/g.test(value) ? value.replaceAll(/(^'|'$)/g, "") : /* v8 ignore next -- @preserve */ value;
+	}
 	let paramName = "";
 	if (parameterized) params.push(paramValue);
 	else {
@@ -5353,6 +6128,12 @@ const derivePathInfo = (path, childCount, { disabled = false, disabledPaths = []
 };
 //#endregion
 //#region src/utils/generateAccessibleDescription.ts
+/**
+* The default `accessibleDescriptionGenerator`. Produces the `aria-label` for a rule group:
+* `"Query builder"` for the root group, `"Rule group at path 0-1"` for any other.
+*
+* @group Accessibility
+*/
 const generateAccessibleDescription = (params) => pathsAreEqual([], params.path) ? `Query builder` : `Rule group at path ${params.path.join("-")}`;
 //#endregion
 //#region src/utils/generateID.ts
@@ -5391,6 +6172,29 @@ if (cryptoModule) {
 	}
 }
 //#endregion
+//#region src/utils/immerInstances.ts
+/**
+* Globally enables or disables immer's auto-freeze, i.e. the deep freeze applied to every query
+* returned by {@link add}, {@link update}, {@link remove}, {@link move}, {@link insert}, and
+* {@link group}.
+*
+* Re-exported from immer so that consumers mixing these tools with their own `produce` calls can
+* switch both at once. Prefer the per-call `freeze` option, or the {@link QueryManager} option of
+* the same name, when the change should not be process-wide. A per-call `freeze: false` wins
+* regardless of this setting; a per-call `freeze: true` does not re-enable freezing once this has
+* turned it off, since it selects immer's default instance.
+*
+* @group Query Tools
+*/
+const setAutoFreeze = setAutoFreeze$1;
+const unfrozenImmer = new Immer({ autoFreeze: false });
+/**
+* The `produce` implementation matching the requested freeze behavior.
+*
+* @internal
+*/
+const producerFor = (freeze = true) => freeze ? produce : unfrozenImmer.produce;
+//#endregion
 //#region src/utils/getMatchModesUtil.ts
 const dummyFD$1 = {
 	name: "name",
@@ -5661,6 +6465,46 @@ const resolveValueList = ({ field, operator, fieldData, getValues, placeholder,
 	}).optionList;
 };
 //#endregion
+//#region src/utils/optionsEqual.ts
+const isPlainObject = (x) => {
+	const proto = Object.getPrototypeOf(x);
+	return proto === null || proto === Object.prototype;
+};
+/**
+* Structural equality for {@link QueryManagerOptions} values. Arrays and plain objects are
+* compared by value; everything else — functions, class instances, `Map`s, `Date`s — by
+* identity.
+*
+* That split is what makes an options object rebuilt on every render compare equal as long as
+* its _data_ did not change, which is the entire point: a caller that passes object literals
+* (`fields={[...]}`, `translations={{...}}`) hands a fresh identity to every reconfigure, so an
+* identity-only comparison would report a change every time.
+*
+* Comparing functions by identity is deliberate rather than a limitation. Two functions cannot
+* be proven equivalent, so a caller that rebuilds `getDefaultValue` per render must either
+* memoize it or accept the reconfigure.
+*/
+const valuesEqual = (a, b) => {
+	if (Object.is(a, b)) return true;
+	if (Array.isArray(a) || Array.isArray(b)) return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((v, i) => valuesEqual(v, b[i]));
+	if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+	if (Object.getPrototypeOf(a) !== Object.getPrototypeOf(b) || !isPlainObject(a)) return false;
+	const aKeys = Object.keys(a);
+	return aKeys.length === Object.keys(b).length && aKeys.every((k) => valuesEqual(a[k], b[k]));
+};
+/**
+* Whether two {@link QueryManagerOptions} objects describe the same configuration, per
+* {@link valuesEqual}: data by value, functions by identity.
+*
+* {@link QueryManager.reconfigure} uses this to gate itself, so most callers never need it
+* directly. It is exported for framework adapters that decide whether to _call_ `reconfigure`
+* at all — skipping the call avoids building the merged options object in the first place.
+*
+* Nested option objects (`history`, `translations`, …) are descended into rather than compared
+* by identity, so `{ history: { maxHistory: 10 } }` rebuilt per render compares equal.
+*/
+const optionsEqual = (a, b) => valuesEqual(a, b);
+//#endregion
 //#region src/utils/preferProp.ts
 const preferPropDefaultTrue = (prop, context) => prop === false ? false : prop ? true : !(context === false);
 const preferPropDefaultFalse = (prop, context) => prop ? true : prop === false ? false : !!context;
@@ -5781,7 +6625,7 @@ const exceedsMaxLevels = (parentPath, { maxLevels = Infinity } = {}) => !!parent
 *
 * @group Query Tools
 */
-const add = (query, ruleOrGroup, parentPathOrID, options = {}) => produce(query, (q) => addInPlace(q, ruleOrGroup, parentPathOrID, options));
+const add = (query, ruleOrGroup, parentPathOrID, options = {}) => producerFor(options.freeze)(query, (q) => addInPlace(q, ruleOrGroup, parentPathOrID, options));
 /**
 * Adds a rule or group to a query in place.
 *
@@ -5881,6 +6725,14 @@ const normalizeUpdateArgs = (a, b, c, d) => {
 	};
 };
 /**
+* The options argument of an {@link update} call, whose position depends on the argument form.
+* Cheaper than {@link normalizeUpdateArgs} when only the options are needed.
+*/
+const updateOptionsOf = (a, b, c, d) => {
+	var _ref4;
+	return (_ref4 = typeof a === "string" || Array.isArray(a) ? d : c) !== null && _ref4 !== void 0 ? _ref4 : {};
+};
+/**
 * Applies one or more property updates to a query in place. Shared by
 * {@link update} and {@link updateInPlace}.
 */
@@ -5901,7 +6753,7 @@ const applyUpdatesInPlace = (query, a, b, c, d) => {
 *
 * @group Query Tools
 */
-const update = ((query, a, b, c, d) => produce(query, (q) => {
+const update = ((query, a, b, c, d) => producerFor(updateOptionsOf(a, b, c, d).freeze)(query, (q) => {
 	applyUpdatesInPlace(q, a, b, c, d);
 }));
 /**
@@ -5949,13 +6801,14 @@ const updateInPlaceSingle = (query, prop, value, pathOrID, options = {}) => {
 			return query;
 		}
 		const parentRules = parent.rules;
-		if (path.at(-1) % 2 === 1) if (parentRules[path.at(-1)] === value) onAbort === null || onAbort === void 0 || onAbort({
-			reason: "no-change",
-			operation: "update",
-			pathOrID
-		});
-		else parentRules[path.at(-1)] = value;
-		else onAbort === null || onAbort === void 0 || onAbort({
+		if (path.at(-1) % 2 === 1) {
+			if (parentRules[path.at(-1)] === value) onAbort === null || onAbort === void 0 || onAbort({
+				reason: "no-change",
+				operation: "update",
+				pathOrID
+			});
+			else parentRules[path.at(-1)] = value;
+		} else onAbort === null || onAbort === void 0 || onAbort({
 			reason: "not-a-combinator-slot",
 			operation: "update",
 			pathOrID
@@ -6026,7 +6879,7 @@ const updateInPlaceSingle = (query, prop, value, pathOrID, options = {}) => {
 *
 * @group Query Tools
 */
-const remove = (query, pathOrID, options = {}) => produce(query, (q) => removeInPlace(q, pathOrID, options));
+const remove = (query, pathOrID, options = {}) => producerFor(options.freeze)(query, (q) => removeInPlace(q, pathOrID, options));
 /**
 * Removes a rule or group from a query in place.
 *
@@ -6081,25 +6934,28 @@ const removeInPlace = (query, pathOrID, options = {}) => {
 const getNextPath = (query, currentPath, newPathOrShiftDirection) => {
 	if (Array.isArray(newPathOrShiftDirection)) return newPathOrShiftDirection;
 	const ic = isRuleGroupTypeIC(query);
-	if (newPathOrShiftDirection === "up") if (pathsAreEqual(currentPath, [0])) return currentPath;
-	else if (currentPath.at(-1) === 0) {
-		const parentPath = getParentPath(currentPath);
-		return [...getParentPath(parentPath), Math.max(0, parentPath.at(-1) - (ic ? 1 : 0))];
-	} else {
-		const evaluationPath = [...getParentPath(currentPath), Math.max(0, currentPath.at(-1) - (ic ? 2 : 1))];
-		const entityAtTarget = findPath(evaluationPath, query);
-		if (isRuleGroup(entityAtTarget)) return [...evaluationPath, entityAtTarget.rules.length];
-		else return [...getParentPath(currentPath), Math.max(0, currentPath.at(-1) - (ic ? 3 : 1))];
-	}
-	else if (newPathOrShiftDirection === "down") if (pathsAreEqual([query.rules.length - 1], currentPath)) return currentPath;
-	else if (currentPath.at(-1) === findPath(getParentPath(currentPath), query).rules.length - 1) {
-		const parentPath = getParentPath(currentPath);
-		return [...getParentPath(parentPath), parentPath.at(-1) + 1];
-	} else {
-		const evaluationPath = [...getParentPath(currentPath), currentPath.at(-1) + (ic ? 2 : 1)];
-		const entityToEvaluate = findPath(evaluationPath, query);
-		if (isRuleGroup(entityToEvaluate)) return [...evaluationPath, 0];
-		else return [...getParentPath(currentPath), currentPath.at(-1) + (ic ? 3 : 2)];
+	if (newPathOrShiftDirection === "up") {
+		if (pathsAreEqual(currentPath, [0])) return currentPath;
+		else if (currentPath.at(-1) === 0) {
+			const parentPath = getParentPath(currentPath);
+			return [...getParentPath(parentPath), Math.max(0, parentPath.at(-1) - (ic ? 1 : 0))];
+		} else {
+			const evaluationPath = [...getParentPath(currentPath), Math.max(0, currentPath.at(-1) - (ic ? 2 : 1))];
+			const entityAtTarget = findPath(evaluationPath, query);
+			if (isRuleGroup(entityAtTarget)) return [...evaluationPath, entityAtTarget.rules.length];
+			else return [...getParentPath(currentPath), Math.max(0, currentPath.at(-1) - (ic ? 3 : 1))];
+		}
+	} else if (newPathOrShiftDirection === "down") {
+		if (pathsAreEqual([query.rules.length - 1], currentPath)) return currentPath;
+		else if (currentPath.at(-1) === findPath(getParentPath(currentPath), query).rules.length - 1) {
+			const parentPath = getParentPath(currentPath);
+			return [...getParentPath(parentPath), parentPath.at(-1) + 1];
+		} else {
+			const evaluationPath = [...getParentPath(currentPath), currentPath.at(-1) + (ic ? 2 : 1)];
+			const entityToEvaluate = findPath(evaluationPath, query);
+			if (isRuleGroup(entityToEvaluate)) return [...evaluationPath, 0];
+			else return [...getParentPath(currentPath), currentPath.at(-1) + (ic ? 3 : 2)];
+		}
 	}
 	return currentPath;
 };
@@ -6111,7 +6967,7 @@ const getNextPath = (query, currentPath, newPathOrShiftDirection) => {
 *
 * @group Query Tools
 */
-const move = (query, oldPathOrID, newPath, options = {}) => produce(query, (q) => moveInPlace(q, oldPathOrID, newPath, options));
+const move = (query, oldPathOrID, newPath, options = {}) => producerFor(options.freeze)(query, (q) => moveInPlace(q, oldPathOrID, newPath, options));
 /**
 * Moves a rule or group from one path to another in place.
 * In the options parameter, pass `{ clone: true }` to copy instead of move.
@@ -6207,15 +7063,16 @@ const moveInPlace = (query, oldPathOrID, newPath, options = {}) => {
 	*/
 	const insertRuleOrGroup = (...args) => parentToInsertInto.rules.splice(spliceIndex, 0, ...args);
 	if (parentToInsertInto.rules.length === 0 || !independentCombinators) insertRuleOrGroup(ruleOrGroup);
-	else if (newIndex === 0) if (ruleToRemoveIndex === 0 && oldNextCombinator) insertRuleOrGroup(ruleOrGroup, oldNextCombinator);
-	else {
-		var _ref4, _parentToInsertInto$r;
-		insertRuleOrGroup(ruleOrGroup, (_ref4 = (_parentToInsertInto$r = parentToInsertInto.rules[1]) !== null && _parentToInsertInto$r !== void 0 ? _parentToInsertInto$r : oldPrevCombinator) !== null && _ref4 !== void 0 ? _ref4 : getFirstOption(combinators));
-	}
-	else if (oldPrevCombinator) insertRuleOrGroup(oldPrevCombinator, ruleOrGroup);
+	else if (newIndex === 0) {
+		if (ruleToRemoveIndex === 0 && oldNextCombinator) insertRuleOrGroup(ruleOrGroup, oldNextCombinator);
+		else {
+			var _ref5, _parentToInsertInto$r;
+			insertRuleOrGroup(ruleOrGroup, (_ref5 = (_parentToInsertInto$r = parentToInsertInto.rules[1]) !== null && _parentToInsertInto$r !== void 0 ? _parentToInsertInto$r : oldPrevCombinator) !== null && _ref5 !== void 0 ? _ref5 : getFirstOption(combinators));
+		}
+	} else if (oldPrevCombinator) insertRuleOrGroup(oldPrevCombinator, ruleOrGroup);
 	else {
-		var _ref5, _parentToInsertInto$r2;
-		insertRuleOrGroup((_ref5 = (_parentToInsertInto$r2 = parentToInsertInto.rules[spliceIndex - 2]) !== null && _parentToInsertInto$r2 !== void 0 ? _parentToInsertInto$r2 : oldNextCombinator) !== null && _ref5 !== void 0 ? _ref5 : getFirstOption(combinators), ruleOrGroup);
+		var _ref6, _parentToInsertInto$r2;
+		insertRuleOrGroup((_ref6 = (_parentToInsertInto$r2 = parentToInsertInto.rules[spliceIndex - 2]) !== null && _parentToInsertInto$r2 !== void 0 ? _parentToInsertInto$r2 : oldNextCombinator) !== null && _ref6 !== void 0 ? _ref6 : getFirstOption(combinators), ruleOrGroup);
 	}
 	return query;
 };
@@ -6226,7 +7083,7 @@ const moveInPlace = (query, oldPathOrID, newPath, options = {}) => {
 *
 * @group Query Tools
 */
-const insert = (query, ruleOrGroup, path, options = {}) => produce(query, (q) => insertInPlace(q, ruleOrGroup, path, options));
+const insert = (query, ruleOrGroup, path, options = {}) => producerFor(options.freeze)(query, (q) => insertInPlace(q, ruleOrGroup, path, options));
 /**
 * Inserts a rule or group into a query in place.
 *
@@ -6285,15 +7142,15 @@ const insertInPlace = (query, ruleOrGroup, path, options = {}) => {
 		var _rorg$path;
 		if (((_rorg$path = rorg.path) === null || _rorg$path === void 0 ? void 0 : _rorg$path.at(-1)) === 0 && combinatorSucceeding) insertRuleOrGroup(newIndex, rorg, combinatorSucceeding);
 		else {
-			var _ref6, _parentToInsertInto$r3;
-			insertRuleOrGroup(newIndex, rorg, (_ref6 = (_parentToInsertInto$r3 = parentToInsertInto.rules[1]) !== null && _parentToInsertInto$r3 !== void 0 ? _parentToInsertInto$r3 : combinatorPreceding) !== null && _ref6 !== void 0 ? _ref6 : getFirstOption(combinators));
+			var _ref7, _parentToInsertInto$r3;
+			insertRuleOrGroup(newIndex, rorg, (_ref7 = (_parentToInsertInto$r3 = parentToInsertInto.rules[1]) !== null && _parentToInsertInto$r3 !== void 0 ? _parentToInsertInto$r3 : combinatorPreceding) !== null && _ref7 !== void 0 ? _ref7 : getFirstOption(combinators));
 		}
 	} else {
 		const normalizedNewIndex = newIndex % 2 === 0 ? newIndex - 1 : newIndex;
 		if (combinatorPreceding) insertRuleOrGroup(normalizedNewIndex, combinatorPreceding, rorg);
 		else {
-			var _ref7, _parentToInsertInto$r4;
-			insertRuleOrGroup(normalizedNewIndex, (_ref7 = (_parentToInsertInto$r4 = parentToInsertInto.rules[normalizedNewIndex - 2]) !== null && _parentToInsertInto$r4 !== void 0 ? _parentToInsertInto$r4 : combinatorSucceeding) !== null && _ref7 !== void 0 ? _ref7 : getFirstOption(combinators), rorg);
+			var _ref8, _parentToInsertInto$r4;
+			insertRuleOrGroup(normalizedNewIndex, (_ref8 = (_parentToInsertInto$r4 = parentToInsertInto.rules[normalizedNewIndex - 2]) !== null && _parentToInsertInto$r4 !== void 0 ? _parentToInsertInto$r4 : combinatorSucceeding) !== null && _ref8 !== void 0 ? _ref8 : getFirstOption(combinators), rorg);
 		}
 	}
 	return query;
@@ -6307,7 +7164,7 @@ const insertInPlace = (query, ruleOrGroup, path, options = {}) => {
 *
 * @group Query Tools
 */
-const group = (query, sourcePathOrID, targetPathOrID, options = {}) => produce(query, (q) => groupInPlace(q, sourcePathOrID, targetPathOrID, options));
+const group = (query, sourcePathOrID, targetPathOrID, options = {}) => producerFor(options.freeze)(query, (q) => groupInPlace(q, sourcePathOrID, targetPathOrID, options));
 /**
 * Creates a new group at a target path with its `rules` array containing the current
 * objects at the target path and the source path in place.
@@ -6435,7 +7292,7 @@ const groupInPlace = (query, sourcePathOrID, targetPathOrID, options = {}) => {
 * @group Query Tools
 */
 const createQueryActions = (config = {}) => {
-	const { qbId, combinators, idGenerator, maxLevels = Infinity, queryDisabled, respectDisabled = true, disabledPaths, resetOnFieldChange, resetOnOperatorChange, getRuleDefaultOperator, getValueSources, getRuleDefaultValue, getMatchModes, onAddRule, onAddGroup, onRemove, onMoveRule, onMoveGroup, onGroupRule, onGroupGroup, onLog } = config;
+	const { qbId, combinators, idGenerator, maxLevels = Infinity, queryDisabled, respectDisabled = true, disabledPaths, resetOnFieldChange, resetOnOperatorChange, getRuleDefaultOperator, getValueSources, getRuleDefaultValue, getMatchModes, freeze, onAddRule, onAddGroup, onRemove, onMoveRule, onMoveGroup, onGroupRule, onGroupGroup, onLog } = config;
 	const log = (payload) => onLog === null || onLog === void 0 ? void 0 : onLog(_objectSpread2({ qbId }, payload));
 	const guards = {
 		respectDisabled,
@@ -6469,7 +7326,8 @@ const createQueryActions = (config = {}) => {
 			const newQuery = add(query, newRule, parentPath, {
 				combinators,
 				combinatorPreceding: newRule.combinatorPreceding,
-				idGenerator
+				idGenerator,
+				freeze
 			});
 			log({
 				type: LogType.add,
@@ -6506,7 +7364,8 @@ const createQueryActions = (config = {}) => {
 			const newQuery = add(query, newGroup, parentPath, {
 				combinators,
 				combinatorPreceding: (_combinatorPreceding = newGroup.combinatorPreceding) !== null && _combinatorPreceding !== void 0 ? _combinatorPreceding : void 0,
-				idGenerator
+				idGenerator,
+				freeze
 			});
 			log({
 				type: LogType.add,
@@ -6534,7 +7393,8 @@ const createQueryActions = (config = {}) => {
 				getRuleDefaultOperator,
 				getValueSources,
 				getRuleDefaultValue,
-				getMatchModes
+				getMatchModes,
+				freeze
 			});
 			log({
 				type: LogType.update,
@@ -6567,7 +7427,7 @@ const createQueryActions = (config = {}) => {
 				});
 				return;
 			}
-			const newQuery = remove(query, path);
+			const newQuery = remove(query, path, { freeze });
 			log({
 				type: LogType.remove,
 				query,
@@ -6592,7 +7452,8 @@ const createQueryActions = (config = {}) => {
 			const nextQuery = move(query, oldPath, newPath, {
 				clone,
 				combinators,
-				idGenerator
+				idGenerator,
+				freeze
 			});
 			const isGroup = isRuleGroup(ruleOrGroup);
 			const callback = isGroup ? onMoveGroup : onMoveRule;
@@ -6638,7 +7499,8 @@ const createQueryActions = (config = {}) => {
 			const nextQuery = group(query, sourcePath, targetPath, {
 				clone,
 				combinators,
-				idGenerator
+				idGenerator,
+				freeze
 			});
 			const isGroup = isRuleGroup(ruleOrGroup);
 			const callback = isGroup ? onGroupGroup : onGroupRule;
@@ -6683,10 +7545,12 @@ const createQueryActions = (config = {}) => {
 const createRule = ({ fields, getDefaultField, getRuleDefaultOperator, getValueSources, getMatchModes, getRuleDefaultValue, idGenerator = generateID }) => {
 	var _getFirstOption, _getFirstOption2;
 	let field = (_getFirstOption = getFirstOption(fields)) !== null && _getFirstOption !== void 0 ? _getFirstOption : "";
-	if (getDefaultField) if (typeof getDefaultField === "function") {
-		const defaultField = getDefaultField(fields);
-		if (defaultField) field = defaultField;
-	} else field = getDefaultField;
+	if (getDefaultField) {
+		if (typeof getDefaultField === "function") {
+			const defaultField = getDefaultField(fields);
+			if (defaultField) field = defaultField;
+		} else field = getDefaultField;
+	}
 	const fieldData = getOption(fields, field);
 	const operator = getRuleDefaultOperator(field);
 	const valueSource = (_getFirstOption2 = getFirstOption(getValueSources(field, operator, { fieldData }))) !== null && _getFirstOption2 !== void 0 ? _getFirstOption2 : "value";
@@ -6730,107 +7594,6 @@ const createRuleGroup = ({ combinators, addRuleToNewGroups, createRule: createRu
 	};
 };
 //#endregion
-//#region src/utils/signature.ts
-/**
-* Signature returned when a change alters the _shape_ of the query—rules or groups added,
-* removed, moved, or reordered—rather than the properties of a single node. Structural changes
-* never coalesce with each other, so each one produces its own history entry.
-*/
-const structuralSignature = "~structural";
-/**
-* Signature returned when two queries differ by reference only, with no observable difference
-* in their properties.
-*/
-const unchangedSignature = "";
-/**
-* Returns the list of property names that differ between two nodes, ignoring `rules` (which is
-* compared structurally by the caller).
-*/
-const changedProps = (prev, next) => {
-	const keys = /* @__PURE__ */ new Set([...Object.keys(prev), ...Object.keys(next)]);
-	keys.delete("rules");
-	const changed = [];
-	for (const key of keys) if (!Object.is(prev[key], next[key])) changed.push(key);
-	return changed.toSorted();
-};
-const signatureOfNode = (prev, next, parentId, index) => {
-	var _next$id3;
-	if (prev === next) return "";
-	if (typeof prev === "string" || typeof next === "string") return typeof prev === typeof next ? `${parentId}:combinator[${index}]` : structuralSignature;
-	const prevIsGroup = isRuleGroup(prev);
-	const nextIsGroup = isRuleGroup(next);
-	if (prevIsGroup !== nextIsGroup) return structuralSignature;
-	if (!prevIsGroup || !nextIsGroup) {
-		var _next$id;
-		const props = changedProps(prev, next);
-		return props.length === 0 ? "" : `${(_next$id = next.id) !== null && _next$id !== void 0 ? _next$id : ""}:${props.join(",")}`;
-	}
-	if (prev.rules.length !== next.rules.length) return structuralSignature;
-	const ownProps = changedProps(prev, next);
-	let changedIndex = -1;
-	for (const [i, prevRule] of prev.rules.entries()) if (prevRule !== next.rules[i]) {
-		if (changedIndex !== -1) return structuralSignature;
-		changedIndex = i;
-	}
-	if (changedIndex === -1) {
-		var _next$id2;
-		return ownProps.length === 0 ? "" : `${(_next$id2 = next.id) !== null && _next$id2 !== void 0 ? _next$id2 : ""}:${ownProps.join(",")}`;
-	}
-	if (ownProps.length > 0) return structuralSignature;
-	return signatureOfNode(prev.rules[changedIndex], next.rules[changedIndex], (_next$id3 = next.id) !== null && _next$id3 !== void 0 ? _next$id3 : "", changedIndex);
-};
-/**
-* Describes _what changed_ between two versions of a query as a short string, so that
-* consecutive edits to the same property of the same rule (e.g. typing in a value editor) can
-* be recognized and coalesced into a single history entry.
-*
-* Returns {@link structuralSignature} for changes to the shape of the query, {@link unchangedSignature} when the
-* two queries differ by reference only, and `"<id>:<props>"` otherwise.
-*
-* The walk prunes on reference equality, so it costs O(depth) rather than O(size) for the
-* single-node edits that make up the overwhelming majority of changes.
-*
-* Note that this relies on the structural sharing that Immer—and therefore every query
-* produced by RQB's own update functions—guarantees: nodes that did not change keep their
-* identity. A query that has been wholly rebuilt (deep-cloned, round-tripped through JSON,
-* re-parsed from a string) shares no identity with its predecessor, so it is reported as
-* {@link structuralSignature} and will not coalesce. That is a graceful degradation—every change simply
-* gets its own history entry—but controlled components that clone the query on every change
-* will not benefit from coalescing.
-*/
-const signatureOf = (prev, next) => signatureOfNode(prev, next, "", -1);
-//#endregion
-//#region \0@oxc-project+runtime@0.142.0/helpers/esm/checkPrivateRedeclaration.js
-function _checkPrivateRedeclaration(e, t) {
-	if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object");
-}
-//#endregion
-//#region \0@oxc-project+runtime@0.142.0/helpers/esm/classPrivateMethodInitSpec.js
-function _classPrivateMethodInitSpec(e, a) {
-	_checkPrivateRedeclaration(e, a), a.add(e);
-}
-//#endregion
-//#region \0@oxc-project+runtime@0.142.0/helpers/esm/classPrivateFieldInitSpec.js
-function _classPrivateFieldInitSpec(e, t, a) {
-	_checkPrivateRedeclaration(e, t), t.set(e, a);
-}
-//#endregion
-//#region \0@oxc-project+runtime@0.142.0/helpers/esm/assertClassBrand.js
-function _assertClassBrand(e, t, n) {
-	if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
-	throw new TypeError("Private element is not present on this object");
-}
-//#endregion
-//#region \0@oxc-project+runtime@0.142.0/helpers/esm/classPrivateFieldGet2.js
-function _classPrivateFieldGet2(s, a) {
-	return s.get(_assertClassBrand(s, a));
-}
-//#endregion
-//#region \0@oxc-project+runtime@0.142.0/helpers/esm/classPrivateFieldSet2.js
-function _classPrivateFieldSet2(s, a, r) {
-	return s.set(_assertClassBrand(s, a), r), r;
-}
-//#endregion
 //#region src/utils/QueryManager.ts
 const _excluded = ["strict", "onInvalidTarget"];
 const _excluded2 = ["strict", "onInvalidTarget"];
@@ -6840,25 +7603,6 @@ const _excluded5 = ["strict", "onInvalidTarget"];
 const _excluded6 = ["strict", "onInvalidTarget"];
 let _Symbol$iterator;
 /**
-* Abort reasons that {@link QueryManager}'s `strict` mode treats as errors. The remaining
-* reasons—`"same-location"` and `"no-change"`—describe valid operations that had nothing to do,
-* so they are reported to `onInvalidTarget` but never throw.
-*
-* @group Query Tools
-*/
-const strictAbortReasons = [
-	"target-not-found",
-	"parent-not-found",
-	"parent-not-a-group",
-	"destination-not-found",
-	"root-not-allowed",
-	"not-a-combinator-slot",
-	"target-disabled",
-	"parent-disabled",
-	"max-levels-exceeded"
-];
-const strictAbortReasonSet = new Set(strictAbortReasons);
-/**
 * Thrown by {@link QueryManager} methods in `strict` mode when an operation cannot be carried
 * out because its target could not be used.
 *
@@ -6875,34 +7619,57 @@ var QueryManagerError = class QueryManagerError extends Error {
 		Object.setPrototypeOf(this, QueryManagerError.prototype);
 	}
 };
-var _query = /* @__PURE__ */ new WeakMap();
-var _options = /* @__PURE__ */ new WeakMap();
-var _fields = /* @__PURE__ */ new WeakMap();
-var _fieldMap = /* @__PURE__ */ new WeakMap();
-var _operators = /* @__PURE__ */ new WeakMap();
-var _combinators = /* @__PURE__ */ new WeakMap();
-var _idGenerator = /* @__PURE__ */ new WeakMap();
-var _validator = /* @__PURE__ */ new WeakMap();
-var _strict = /* @__PURE__ */ new WeakMap();
-var _respectDisabled = /* @__PURE__ */ new WeakMap();
-var _onInvalidTarget = /* @__PURE__ */ new WeakMap();
-var _listeners = /* @__PURE__ */ new WeakMap();
-var _historyEnabled = /* @__PURE__ */ new WeakMap();
-var _maxHistory = /* @__PURE__ */ new WeakMap();
-var _coalesceMs = /* @__PURE__ */ new WeakMap();
-var _now = /* @__PURE__ */ new WeakMap();
-var _configVersion = /* @__PURE__ */ new WeakMap();
-var _past = /* @__PURE__ */ new WeakMap();
-var _future = /* @__PURE__ */ new WeakMap();
-var _lastSig = /* @__PURE__ */ new WeakMap();
-var _lastAt = /* @__PURE__ */ new WeakMap();
-var _batchDepth = /* @__PURE__ */ new WeakMap();
-var _batchSnapshot = /* @__PURE__ */ new WeakMap();
-var _historyBypassed = /* @__PURE__ */ new WeakMap();
-var _cacheFor = /* @__PURE__ */ new WeakMap();
-var _idPathIndex = /* @__PURE__ */ new WeakMap();
-var _validation = /* @__PURE__ */ new WeakMap();
-var _QueryManager_brand = /* @__PURE__ */ new WeakSet();
+/**
+* Key of the single own property holding every {@link QueryManager} instance's state.
+*
+* `#private` fields are unreachable from a `Proxy`: inside a method invoked through one, `this`
+* _is_ the proxy, and the private brand lives on the target, so every access throws
+* `TypeError: Cannot read private member`. Frameworks wrap objects in proxies routinely — Vue's
+* `reactive()`, and by extension Vue Test Utils' handling of mount props, do it implicitly — so
+* consumers hit that failure by accident rather than by choice.
+*
+* A `WeakMap` keyed by instance does not fix it either, for the same reason: `weakMap.get(this)`
+* misses the entry stored under the target. An ordinary own property is the only mechanism that
+* reads correctly through a proxy, because the `get` trap forwards to the target.
+*
+* The symbol is module-private and never exported. Reaching into the state bag (via
+* `Object.getOwnPropertySymbols`, say) is not a supported access path and its contents may change
+* in any release.
+*/
+const kState = Symbol("QueryManager.state");
+const queryChange = freeze({
+	query: true,
+	config: false
+});
+const configChange = freeze({
+	query: false,
+	config: true
+});
+const queryAndConfigChange = freeze({
+	query: true,
+	config: true
+});
+/**
+* Builds the state bag. The option-derived members are left unset for `applyOptions` to fill in,
+* hence the assertion.
+*/
+const createManagerState = () => {
+	const state = {
+		listeners: /* @__PURE__ */ new Set(),
+		configVersion: 0,
+		past: [],
+		future: [],
+		lastAt: 0,
+		batchDepth: 0,
+		historyBypassed: false,
+		pendingConfigNotify: false
+	};
+	Object.defineProperty(state, "__v_skip", {
+		value: true,
+		enumerable: false
+	});
+	return state;
+};
 _Symbol$iterator = Symbol.iterator;
 /**
 * Stateful wrapper around the {@link add}/{@link remove}/{@link update}/{@link move}/
@@ -6912,7 +7679,8 @@ _Symbol$iterator = Symbol.iterator;
 * The query is held internally, so each method takes the same arguments as its `queryTools`
 * counterpart minus the leading `query` parameter, and returns the manager itself for chaining.
 * Mutations use the non-`InPlace` tools, so a query previously handed out by
-* {@link QueryManager.getQuery} is never modified.
+* {@link QueryManager.getQuery} is never modified. Under `freeze: false` that remains true, but
+* as a convention rather than a runtime-enforced guarantee.
 *
 * ```ts
 * const q = new QueryManager(undefined, { fields });
@@ -6928,46 +7696,31 @@ _Symbol$iterator = Symbol.iterator;
 * @group Query Tools
 */
 var QueryManager = class QueryManager {
+	/**
+	* All instance state, rather than `#private` fields. See `kState` for why.
+	*
+	* The property itself is symbol-keyed and installed by the constructor; this accessor exists
+	* because `isolatedDeclarations` cannot emit a computed property name keyed by a symbol the
+	* module does not export, and exporting it would put it in the public API surface. A
+	* prototype accessor is proxy-safe for the same reason the own property is: `this` is the
+	* proxy, and the `get` trap forwards to the target.
+	*/
+	get state() {
+		return this[kState];
+	}
 	constructor(query, options = {}) {
-		_classPrivateMethodInitSpec(this, _QueryManager_brand);
-		_classPrivateFieldInitSpec(this, _query, void 0);
-		_classPrivateFieldInitSpec(this, _options, void 0);
-		_classPrivateFieldInitSpec(this, _fields, void 0);
-		_classPrivateFieldInitSpec(this, _fieldMap, void 0);
-		_classPrivateFieldInitSpec(this, _operators, void 0);
-		_classPrivateFieldInitSpec(this, _combinators, void 0);
-		_classPrivateFieldInitSpec(this, _idGenerator, void 0);
-		_classPrivateFieldInitSpec(this, _validator, void 0);
-		_classPrivateFieldInitSpec(this, _strict, void 0);
-		_classPrivateFieldInitSpec(this, _respectDisabled, void 0);
-		_classPrivateFieldInitSpec(this, _onInvalidTarget, void 0);
-		_classPrivateFieldInitSpec(this, _listeners, /* @__PURE__ */ new Set());
-		_classPrivateFieldInitSpec(this, _historyEnabled, void 0);
-		_classPrivateFieldInitSpec(this, _maxHistory, void 0);
-		_classPrivateFieldInitSpec(this, _coalesceMs, void 0);
-		_classPrivateFieldInitSpec(this, _now, void 0);
-		_classPrivateFieldInitSpec(this, _configVersion, 0);
-		_classPrivateFieldInitSpec(this, _past, []);
-		_classPrivateFieldInitSpec(this, _future, []);
-		_classPrivateFieldInitSpec(this, _lastSig, void 0);
-		_classPrivateFieldInitSpec(this, _lastAt, 0);
-		_classPrivateFieldInitSpec(this, _batchDepth, 0);
-		_classPrivateFieldInitSpec(this, _batchSnapshot, void 0);
-		_classPrivateFieldInitSpec(this, _historyBypassed, false);
-		_classPrivateFieldInitSpec(this, _cacheFor, void 0);
-		_classPrivateFieldInitSpec(this, _idPathIndex, void 0);
-		_classPrivateFieldInitSpec(this, _validation, void 0);
 		_defineProperty(
 			this,
 			/**
-			* The current query. The returned object is frozen and structurally shared, so it is safe to
-			* retain and compare by reference to detect changes.
+			* The current query. The returned object is structurally shared, so it is safe to retain and
+			* compare by reference to detect changes. It is also frozen unless the `freeze` option is
+			* `false`.
 			*
 			* Like {@link QueryManager.subscribe}, this method is bound to the instance, so it can be
 			* passed as a bare reference (e.g. as the `getSnapshot` argument to `useSyncExternalStore`).
 			*/
 			"getQuery",
-			() => _classPrivateFieldGet2(_query, this)
+			() => this.state.query
 		);
 		_defineProperty(
 			this,
@@ -6981,7 +7734,7 @@ var QueryManager = class QueryManager {
 			* already does this.
 			*/
 			"getConfigVersion",
-			() => _classPrivateFieldGet2(_configVersion, this)
+			() => this.state.configVersion
 		);
 		_defineProperty(
 			this,
@@ -6999,21 +7752,282 @@ var QueryManager = class QueryManager {
 			* ```
 			*
 			* In React, prefer the `useQueryManager` hook from `react-querybuilder`, which wraps this.
+			*
+			* The listener receives a {@link SubscriptionChange} describing what changed. It is optional:
+			* a zero-argument listener — including `useSyncExternalStore`'s `onStoreChange` — is still a
+			* valid listener and behaves as it always has.
 			*/
 			"subscribe",
 			(listener) => {
-				_classPrivateFieldGet2(_listeners, this).add(listener);
+				this.state.listeners.add(listener);
 				return () => {
-					_classPrivateFieldGet2(_listeners, this).delete(listener);
+					this.state.listeners.delete(listener);
 				};
 			}
 		);
-		_assertClassBrand(_QueryManager_brand, this, _applyOptions).call(this, options);
-		_classPrivateFieldSet2(_query, this, freeze(query ? prepareRuleGroup(query, { idGenerator: _classPrivateFieldGet2(_idGenerator, this) }) : this.createRuleGroup(), true));
+		Object.defineProperty(this, kState, {
+			value: createManagerState(),
+			enumerable: false,
+			writable: false,
+			configurable: false
+		});
+		this.applyOptions(options);
+		this.state.query = this.freeze(query ? prepareRuleGroup(query, { idGenerator: this.state.idGenerator }) : this.createRuleGroup());
+	}
+	/**
+	* Deep-freezes `x` unless the `freeze` option is `false`. Every value the manager hands out
+	* directly goes through here; the shallow copies returned by {@link QueryManager.getOptions}
+	* and passed to `applyOptions` are frozen unconditionally instead.
+	*/
+	freeze(x) {
+		return this.state.freezeEnabled ? freeze(x, true) : x;
+	}
+	/**
+	* Assigns `options` and every field derived from it. Shared by the constructor and
+	* {@link QueryManager.reconfigure}, so the two can never drift apart. Does not touch the
+	* query, the history stacks, the caches, or the subscriber list.
+	*/
+	applyOptions(options) {
+		var _options$freeze, _options$idGenerator, _options$validator, _options$strict, _options$respectDisab, _options$history, _historyOptions$maxHi, _historyOptions$coale, _options$now, _options$translations, _options$operators, _options$translations2, _options$combinators;
+		this.state.options = options;
+		this.state.freezeEnabled = (_options$freeze = options.freeze) !== null && _options$freeze !== void 0 ? _options$freeze : true;
+		this.state.idGenerator = (_options$idGenerator = options.idGenerator) !== null && _options$idGenerator !== void 0 ? _options$idGenerator : generateID;
+		this.state.validator = (_options$validator = options.validator) !== null && _options$validator !== void 0 ? _options$validator : defaultValidator;
+		this.state.strict = (_options$strict = options.strict) !== null && _options$strict !== void 0 ? _options$strict : false;
+		this.state.respectDisabled = (_options$respectDisab = options.respectDisabled) !== null && _options$respectDisab !== void 0 ? _options$respectDisab : true;
+		this.state.onInvalidTarget = options.onInvalidTarget;
+		const history = (_options$history = options.history) !== null && _options$history !== void 0 ? _options$history : false;
+		const historyOptions = typeof history === "object" ? history : {};
+		this.state.historyEnabled = history !== false;
+		this.state.maxHistory = (_historyOptions$maxHi = historyOptions.maxHistory) !== null && _historyOptions$maxHi !== void 0 ? _historyOptions$maxHi : 50;
+		this.state.coalesceMs = (_historyOptions$coale = historyOptions.coalesceMs) !== null && _historyOptions$coale !== void 0 ? _historyOptions$coale : 500;
+		this.state.now = (_options$now = options.now) !== null && _options$now !== void 0 ? _options$now : Date.now;
+		const { optionList: fields, optionsMap: fieldMap } = prepareOptionList({
+			optionList: options.fields,
+			baseOption: options.baseField,
+			autoSelectOption: options.autoSelectField,
+			placeholder: (_options$translations = options.translations) === null || _options$translations === void 0 ? void 0 : _options$translations.fields
+		});
+		this.state.fields = this.freeze(fields);
+		this.state.fieldMap = this.freeze(fieldMap);
+		this.state.operators = prepareOptionList({
+			optionList: (_options$operators = options.operators) !== null && _options$operators !== void 0 ? _options$operators : defaultOperators,
+			baseOption: options.baseOperator,
+			labelMap: defaultOperatorLabelMap,
+			autoSelectOption: options.autoSelectOperator,
+			placeholder: (_options$translations2 = options.translations) === null || _options$translations2 === void 0 ? void 0 : _options$translations2.operators
+		}).optionList;
+		this.state.combinators = this.freeze(prepareOptionList({
+			optionList: (_options$combinators = options.combinators) !== null && _options$combinators !== void 0 ? _options$combinators : defaultCombinators,
+			baseOption: options.baseCombinator
+		}).optionList);
+	}
+	/** Resolves the field configuration for a field name. */
+	fieldData(field) {
+		var _field;
+		return (_field = this.state.fieldMap[field]) !== null && _field !== void 0 ? _field : {};
+	}
+	/** Resolves the operator list for a field, mirroring `QueryBuilder`'s precedence. */
+	operatorsFor(field) {
+		var _this$state$options$t;
+		return resolveOperatorList({
+			field,
+			fieldData: this.fieldData(field),
+			getOperators: this.state.options.getOperators,
+			operators: this.state.operators,
+			baseOption: this.state.options.baseOperator,
+			autoSelectOption: this.state.options.autoSelectOperator,
+			placeholder: (_this$state$options$t = this.state.options.translations) === null || _this$state$options$t === void 0 ? void 0 : _this$state$options$t.operators
+		});
+	}
+	/** Resolves the default operator for a field, mirroring `QueryBuilder`'s precedence. */
+	defaultOperator(field) {
+		return resolveDefaultOperator({
+			field,
+			fieldData: this.fieldData(field),
+			getDefaultOperator: this.state.options.getDefaultOperator,
+			getOperators: (f) => this.operatorsFor(f)
+		});
+	}
+	valueSourcesFor(field, operator) {
+		return getValueSourcesUtil(this.fieldData(field), operator, this.state.options.getValueSources);
+	}
+	matchModesFor(field) {
+		return getMatchModesUtil(this.fieldData(field), this.state.options.getMatchModes);
+	}
+	valuesFor(field, operator) {
+		var _this$state$options$t2;
+		return resolveValueList({
+			field,
+			operator,
+			fieldData: this.fieldData(field),
+			getValues: this.state.options.getValues,
+			autoSelectOption: this.state.options.autoSelectValue,
+			placeholder: (_this$state$options$t2 = this.state.options.translations) === null || _this$state$options$t2 === void 0 ? void 0 : _this$state$options$t2.values
+		});
+	}
+	valueEditorTypeFor(field, operator) {
+		return resolveValueEditorType({
+			field,
+			operator,
+			fieldData: this.fieldData(field),
+			getValueEditorType: this.state.options.getValueEditorType
+		});
+	}
+	/** Computes the default `value` for a rule, mirroring `QueryBuilder`'s precedence. */
+	defaultValue(rule) {
+		const { getDefaultValue, getParameters, listsAsArrays } = this.state.options;
+		return getRuleDefaultValue(rule, {
+			fieldData: this.fieldData(rule.field),
+			fields: this.state.fields,
+			listsAsArrays,
+			getValueEditorType: (f, o) => this.valueEditorTypeFor(f, o),
+			getValues: (f, o) => this.valuesFor(f, o),
+			getDefaultValue: getDefaultValue && ((r, misc) => getDefaultValue(r, misc)),
+			getParameters: getParameters && ((f, o, misc) => this.parametersFor(f, o, misc))
+		});
+	}
+	/**
+	* Resolves the parameter list for a field/operator pair, normalized the same way as every
+	* other option list. Shared by `defaultValue` and {@link QueryManager.getRuleContext} so both
+	* see the same shape.
+	*/
+	parametersFor(field, operator, misc) {
+		var _this$state$options$g, _this$state$options$g2, _this$state$options;
+		return prepareOptionList({
+			optionList: (_this$state$options$g = (_this$state$options$g2 = (_this$state$options = this.state.options).getParameters) === null || _this$state$options$g2 === void 0 ? void 0 : _this$state$options$g2.call(_this$state$options, field, operator, misc)) !== null && _this$state$options$g !== void 0 ? _this$state$options$g : [],
+			autoSelectOption: this.state.options.autoSelectValue
+		}).optionList;
+	}
+	/** Defaults shared by every mutating method, overridable per call. */
+	guardOptions() {
+		const { maxLevels } = this.state.options;
+		return {
+			freeze: this.state.freezeEnabled,
+			maxLevels: (maxLevels !== null && maxLevels !== void 0 ? maxLevels : 0) > 0 ? Number(maxLevels) : Infinity,
+			respectDisabled: this.state.respectDisabled,
+			disabledPaths: this.state.options.disabledPaths,
+			queryDisabled: this.state.options.queryDisabled
+		};
+	}
+	toolOptions() {
+		return _objectSpread2({
+			combinators: this.state.combinators,
+			idGenerator: this.state.idGenerator
+		}, this.guardOptions());
+	}
+	/**
+	* Builds the `onAbort` handler passed to the query tools, applying the per-call overrides on
+	* top of the manager's own options.
+	*/
+	onAbort({ strict, onInvalidTarget }) {
+		const strictMain = strict !== null && strict !== void 0 ? strict : this.state.strict;
+		const handler = onInvalidTarget !== null && onInvalidTarget !== void 0 ? onInvalidTarget : this.state.onInvalidTarget;
+		return (info) => {
+			handler === null || handler === void 0 || handler(info);
+			if (strictMain && strictAbortReasonSet.has(info.reason)) throw new QueryManagerError(info);
+		};
+	}
+	/** Defaults for {@link update}, so resets mirror `QueryBuilder`'s behavior. */
+	updateOptions() {
+		return _objectSpread2({
+			getRuleDefaultOperator: (f) => this.defaultOperator(f),
+			getRuleDefaultValue: (r) => this.defaultValue(r),
+			getValueSources: (f, o) => this.valueSourcesFor(f, o),
+			getMatchModes: (f) => this.matchModesFor(f),
+			resetOnFieldChange: this.state.options.resetOnFieldChange,
+			resetOnOperatorChange: this.state.options.resetOnOperatorChange
+		}, this.guardOptions());
+	}
+	/**
+	* Applies a new query, recording history and notifying subscribers as appropriate. Every
+	* mutation funnels through here. A tool that could not resolve its target returns the same
+	* query object, which is treated as a no-op.
+	*/
+	commit(next) {
+		const prev = this.state.query;
+		if (prev === next) return;
+		this.state.query = next;
+		if (this.state.batchDepth > 0) return;
+		this.record(prev, next);
+		this.notify(queryChange);
+	}
+	/**
+	* Records a change, either as a new history entry or by absorbing it into the current one.
+	* Mirrors the recording semantics of the `react-querybuilder/history` entry point.
+	*/
+	record(prev, next) {
+		if (!this.state.historyEnabled) return;
+		const sig = signatureOf(prev, next);
+		if (sig === "") return;
+		const now = this.state.now();
+		if (!shouldCoalesce(this.state.lastSig, sig, this.state.lastAt, now, this.state.coalesceMs)) {
+			this.state.past.push(prev);
+			if (this.state.past.length > this.state.maxHistory) this.state.past.shift();
+			this.state.future = [];
+		}
+		this.state.lastSig = sig;
+		this.state.lastAt = now;
+	}
+	notify(change) {
+		for (const listener of this.state.listeners) listener(change);
+	}
+	/**
+	* Records that a history-stack method ran inside the current batch. Those methods manage
+	* `past`/`future` themselves, so the batch must not also record an entry on completion —
+	* doing so would push a duplicate onto `past` and clear the redo stack that `undo` just
+	* populated.
+	*/
+	markHistoryBypassed() {
+		if (this.state.batchDepth > 0) this.state.historyBypassed = true;
+	}
+	/**
+	* Discards every cached derivation when the query has been replaced since they were computed.
+	* Called at the top of each cached reader.
+	*/
+	ensureCache() {
+		if (this.state.cacheFor === this.state.query) return;
+		this.state.cacheFor = this.state.query;
+		this.state.idPathIndex = void 0;
+		this.state.validation = void 0;
+	}
+	/**
+	* The single traversal implementation. Combinator strings in independent-combinator groups
+	* are skipped.
+	*
+	* @yields The subtree rooted at `node`, depth-first in pre-order, starting with `node` itself.
+	*/
+	*walkFrom(node, path, parent) {
+		yield {
+			node,
+			path,
+			parent
+		};
+		if (!isRuleGroup(node)) return;
+		const startGroup = node;
+		for (const [index, child] of startGroup.rules.entries()) {
+			if (typeof child === "string") continue;
+			yield* this.walkFrom(child, [...path, index], startGroup);
+		}
+	}
+	/** Builds (once per query) the `id` to {@link Path} index backing `findID`/`getPathOfID`. */
+	index() {
+		this.ensureCache();
+		if (!this.state.idPathIndex) {
+			const index = /* @__PURE__ */ new Map();
+			for (const { node, path } of this.walkFrom(this.state.query, [], null)) if (node.id !== void 0 && !index.has(node.id)) index.set(node.id, path);
+			this.state.idPathIndex = index;
+		}
+		return this.state.idPathIndex;
+	}
+	/** Resolves a path or `id` to a path, or `null` when the `id` isn't present. */
+	toPath(pathOrID) {
+		var _this$index$get;
+		return typeof pathOrID === "string" ? (_this$index$get = this.index().get(pathOrID)) !== null && _this$index$get !== void 0 ? _this$index$get : null : pathOrID;
 	}
 	/** Replaces the current query, ensuring every rule and group has an `id`. */
 	setQuery(query) {
-		_assertClassBrand(_QueryManager_brand, this, _commit).call(this, freeze(prepareRuleGroup(query, { idGenerator: _classPrivateFieldGet2(_idGenerator, this) }), true));
+		this.commit(this.freeze(prepareRuleGroup(query, { idGenerator: this.state.idGenerator })));
 		return this;
 	}
 	/**
@@ -7022,13 +8036,13 @@ var QueryManager = class QueryManager {
 	*/
 	createRule() {
 		return createRule({
-			fields: _classPrivateFieldGet2(_fields, this),
-			getDefaultField: _classPrivateFieldGet2(_options, this).getDefaultField,
-			getRuleDefaultOperator: (f) => _assertClassBrand(_QueryManager_brand, this, _defaultOperator).call(this, f),
-			getValueSources: (f, o) => _assertClassBrand(_QueryManager_brand, this, _valueSourcesFor).call(this, f, o),
-			getMatchModes: (f) => _assertClassBrand(_QueryManager_brand, this, _matchModesFor).call(this, f),
-			getRuleDefaultValue: (r) => _assertClassBrand(_QueryManager_brand, this, _defaultValue).call(this, r),
-			idGenerator: _classPrivateFieldGet2(_idGenerator, this)
+			fields: this.state.fields,
+			getDefaultField: this.state.options.getDefaultField,
+			getRuleDefaultOperator: (f) => this.defaultOperator(f),
+			getValueSources: (f, o) => this.valueSourcesFor(f, o),
+			getMatchModes: (f) => this.matchModesFor(f),
+			getRuleDefaultValue: (r) => this.defaultValue(r),
+			idGenerator: this.state.idGenerator
 		});
 	}
 	/**
@@ -7037,10 +8051,10 @@ var QueryManager = class QueryManager {
 	*/
 	createRuleGroup(independentCombinators) {
 		return createRuleGroup({
-			combinators: _classPrivateFieldGet2(_combinators, this),
-			addRuleToNewGroups: _classPrivateFieldGet2(_options, this).addRuleToNewGroups,
+			combinators: this.state.combinators,
+			addRuleToNewGroups: this.state.options.addRuleToNewGroups,
 			createRule: () => this.createRule(),
-			idGenerator: _classPrivateFieldGet2(_idGenerator, this)
+			idGenerator: this.state.idGenerator
 		}, independentCombinators);
 	}
 	/**
@@ -7049,7 +8063,7 @@ var QueryManager = class QueryManager {
 	*/
 	add(ruleOrGroup, parentPathOrID = [], options = {}) {
 		const { strict, onInvalidTarget } = options, toolOptions = _objectWithoutProperties(options, _excluded);
-		_assertClassBrand(_QueryManager_brand, this, _commit).call(this, add(_classPrivateFieldGet2(_query, this), ruleOrGroup, parentPathOrID, _objectSpread2(_objectSpread2(_objectSpread2({}, _assertClassBrand(_QueryManager_brand, this, _toolOptions).call(this)), toolOptions), {}, { onAbort: _assertClassBrand(_QueryManager_brand, this, _onAbort).call(this, {
+		this.commit(add(this.state.query, ruleOrGroup, parentPathOrID, _objectSpread2(_objectSpread2(_objectSpread2({}, this.toolOptions()), toolOptions), {}, { onAbort: this.onAbort({
 			strict,
 			onInvalidTarget
 		}) })));
@@ -7058,7 +8072,7 @@ var QueryManager = class QueryManager {
 	/** Removes the rule or group at the given path or `id`. The root group cannot be removed. */
 	remove(pathOrID, options = {}) {
 		const { strict, onInvalidTarget } = options, toolOptions = _objectWithoutProperties(options, _excluded2);
-		_assertClassBrand(_QueryManager_brand, this, _commit).call(this, remove(_classPrivateFieldGet2(_query, this), pathOrID, _objectSpread2(_objectSpread2(_objectSpread2({}, _assertClassBrand(_QueryManager_brand, this, _guardOptions).call(this)), toolOptions), {}, { onAbort: _assertClassBrand(_QueryManager_brand, this, _onAbort).call(this, {
+		this.commit(remove(this.state.query, pathOrID, _objectSpread2(_objectSpread2(_objectSpread2({}, this.guardOptions()), toolOptions), {}, { onAbort: this.onAbort({
 			strict,
 			onInvalidTarget
 		}) })));
@@ -7074,17 +8088,17 @@ var QueryManager = class QueryManager {
 			d
 		];
 		const _ref = (_args$optionsIndex = args[optionsIndex]) !== null && _args$optionsIndex !== void 0 ? _args$optionsIndex : {}, { strict, onInvalidTarget } = _ref, toolOptions = _objectWithoutProperties(_ref, _excluded3);
-		args[optionsIndex] = _objectSpread2(_objectSpread2(_objectSpread2({}, _assertClassBrand(_QueryManager_brand, this, _updateOptions).call(this)), toolOptions), {}, { onAbort: _assertClassBrand(_QueryManager_brand, this, _onAbort).call(this, {
+		args[optionsIndex] = _objectSpread2(_objectSpread2(_objectSpread2({}, this.updateOptions()), toolOptions), {}, { onAbort: this.onAbort({
 			strict,
 			onInvalidTarget
 		}) });
-		_assertClassBrand(_QueryManager_brand, this, _commit).call(this, update(_classPrivateFieldGet2(_query, this), ...args.slice(0, optionsIndex + 1)));
+		this.commit(update(this.state.query, ...args.slice(0, optionsIndex + 1)));
 		return this;
 	}
 	/** Moves the rule or group at `oldPathOrID` to `newPath`, or shifts it `'up'`/`'down'`. */
 	move(oldPathOrID, newPath, options = {}) {
 		const { strict, onInvalidTarget } = options, toolOptions = _objectWithoutProperties(options, _excluded4);
-		_assertClassBrand(_QueryManager_brand, this, _commit).call(this, move(_classPrivateFieldGet2(_query, this), oldPathOrID, newPath, _objectSpread2(_objectSpread2(_objectSpread2({}, _assertClassBrand(_QueryManager_brand, this, _toolOptions).call(this)), toolOptions), {}, { onAbort: _assertClassBrand(_QueryManager_brand, this, _onAbort).call(this, {
+		this.commit(move(this.state.query, oldPathOrID, newPath, _objectSpread2(_objectSpread2(_objectSpread2({}, this.toolOptions()), toolOptions), {}, { onAbort: this.onAbort({
 			strict,
 			onInvalidTarget
 		}) })));
@@ -7096,7 +8110,7 @@ var QueryManager = class QueryManager {
 	*/
 	insert(ruleOrGroup, path, options = {}) {
 		const { strict, onInvalidTarget } = options, toolOptions = _objectWithoutProperties(options, _excluded5);
-		_assertClassBrand(_QueryManager_brand, this, _commit).call(this, insert(_classPrivateFieldGet2(_query, this), ruleOrGroup, path, _objectSpread2(_objectSpread2(_objectSpread2({}, _assertClassBrand(_QueryManager_brand, this, _toolOptions).call(this)), toolOptions), {}, { onAbort: _assertClassBrand(_QueryManager_brand, this, _onAbort).call(this, {
+		this.commit(insert(this.state.query, ruleOrGroup, path, _objectSpread2(_objectSpread2(_objectSpread2({}, this.toolOptions()), toolOptions), {}, { onAbort: this.onAbort({
 			strict,
 			onInvalidTarget
 		}) })));
@@ -7108,7 +8122,7 @@ var QueryManager = class QueryManager {
 	*/
 	group(sourcePathOrID, targetPathOrID, options = {}) {
 		const { strict, onInvalidTarget } = options, toolOptions = _objectWithoutProperties(options, _excluded6);
-		_assertClassBrand(_QueryManager_brand, this, _commit).call(this, group(_classPrivateFieldGet2(_query, this), sourcePathOrID, targetPathOrID, _objectSpread2(_objectSpread2(_objectSpread2({}, _assertClassBrand(_QueryManager_brand, this, _toolOptions).call(this)), toolOptions), {}, { onAbort: _assertClassBrand(_QueryManager_brand, this, _onAbort).call(this, {
+		this.commit(group(this.state.query, sourcePathOrID, targetPathOrID, _objectSpread2(_objectSpread2(_objectSpread2({}, this.toolOptions()), toolOptions), {}, { onAbort: this.onAbort({
 			strict,
 			onInvalidTarget
 		}) })));
@@ -7120,7 +8134,7 @@ var QueryManager = class QueryManager {
 	* defaults filled in for options that were never provided.
 	*/
 	getOptions() {
-		return freeze(_objectSpread2({}, _classPrivateFieldGet2(_options, this)));
+		return freeze(_objectSpread2({}, this.state.options));
 	}
 	/**
 	* Updates the manager's configuration in place, keeping the current query, the undo/redo
@@ -7143,20 +8157,51 @@ var QueryManager = class QueryManager {
 	* re-normalize.
 	*
 	* History options are honored immediately: lowering `maxHistory` trims the undo stack, and
-	* turning history off clears both stacks. Subscribers are notified once, and
-	* {@link QueryManager.getConfigVersion} is incremented, even inside a
-	* {@link QueryManager.batch batch} — configuration is not part of a batch's rollback.
+	* turning history off clears both stacks.
+	*
+	* A call that resolves to the configuration already in effect is a **no-op**: nothing is
+	* re-derived, {@link QueryManager.getConfigVersion} does not change, and subscribers are not
+	* notified. Equality is structural for data and by identity for functions
+	* ({@link optionsEqual}), so a caller that rebuilds its options object on every render — which
+	* every framework adapter does — does not force a reconfigure as long as the data is the same.
+	* Rebuilding a callback per render _does_ count as a change; memoize it to avoid that.
+	*
+	* Otherwise subscribers are notified once and `getConfigVersion` is incremented. Inside a
+	* {@link QueryManager.batch batch} the options are still applied immediately — configuration
+	* is not part of a batch's rollback — but the notification is deferred and merged into the
+	* batch's single notification.
 	*/
 	reconfigure(options, config) {
-		var _this$configVersion;
-		_assertClassBrand(_QueryManager_brand, this, _applyOptions).call(this, freeze((config === null || config === void 0 ? void 0 : config.replace) ? _objectSpread2({}, options) : _objectSpread2(_objectSpread2({}, _classPrivateFieldGet2(_options, this)), options)));
-		_classPrivateFieldSet2(_validation, this, void 0);
-		_assertClassBrand(_QueryManager_brand, this, _reconcileHistoryConfig).call(this);
-		_classPrivateFieldSet2(_configVersion, this, (_this$configVersion = _classPrivateFieldGet2(_configVersion, this), ++_this$configVersion));
-		_assertClassBrand(_QueryManager_brand, this, _notify).call(this);
+		const merged = (config === null || config === void 0 ? void 0 : config.replace) ? _objectSpread2({}, options) : _objectSpread2(_objectSpread2({}, this.state.options), options);
+		if (optionsEqual(this.state.options, merged)) return this;
+		this.applyOptions(freeze(merged));
+		this.state.validation = void 0;
+		this.reconcileHistoryConfig();
+		++this.state.configVersion;
+		if (this.state.batchDepth > 0) this.state.pendingConfigNotify = true;
+		else this.notify(configChange);
 		return this;
 	}
 	/**
+	* Brings the history stacks in line with the current history configuration. Unlike
+	* {@link QueryManager.clearHistory}, this does _not_ set `historyBypassed`: it reflects a
+	* configuration change rather than a deliberate history repositioning, so a later mutation in
+	* the same batch must still be recorded normally.
+	*
+	* Called by {@link QueryManager.reconfigure} and again after a failed
+	* {@link QueryManager.batch batch} restores its snapshot, since that snapshot predates the
+	* configuration change (configuration is not part of a batch's rollback).
+	*/
+	reconcileHistoryConfig() {
+		if (this.state.historyEnabled) {
+			if (this.state.past.length > this.state.maxHistory) this.state.past.splice(0, this.state.past.length - this.state.maxHistory);
+		} else {
+			this.state.past = [];
+			this.state.future = [];
+			this.state.lastSig = void 0;
+		}
+	}
+	/**
 	* Creates an independent manager with the same configuration and the current query.
 	*
 	* Subscribers and history are _not_ carried over: the clone starts with no listeners and an
@@ -7167,8 +8212,8 @@ var QueryManager = class QueryManager {
 	* is useful when both queries will be used together (e.g. inserted into the same tree).
 	*/
 	clone(options) {
-		const query = (options === null || options === void 0 ? void 0 : options.regenerateIDs) ? regenerateIDs(_classPrivateFieldGet2(_query, this), { idGenerator: _classPrivateFieldGet2(_idGenerator, this) }) : _classPrivateFieldGet2(_query, this);
-		return new QueryManager(query, _classPrivateFieldGet2(_options, this));
+		const query = (options === null || options === void 0 ? void 0 : options.regenerateIDs) ? regenerateIDs(this.state.query, { idGenerator: this.state.idGenerator }) : this.state.query;
+		return new QueryManager(query, this.state.options);
 	}
 	/**
 	* Runs `fn`, deferring history recording and subscriber notification until it returns. The
@@ -7185,77 +8230,78 @@ var QueryManager = class QueryManager {
 	* its own, leaving the stacks exactly as those methods left them.
 	*/
 	batch(fn) {
-		var _this$batchDepth;
-		_classPrivateFieldSet2(_batchDepth, this, (_this$batchDepth = _classPrivateFieldGet2(_batchDepth, this), _this$batchDepth++, _this$batchDepth));
-		if (_classPrivateFieldGet2(_batchDepth, this) === 1) _classPrivateFieldSet2(_batchSnapshot, this, {
-			query: _classPrivateFieldGet2(_query, this),
-			past: [..._classPrivateFieldGet2(_past, this)],
-			future: [..._classPrivateFieldGet2(_future, this)],
-			lastSig: _classPrivateFieldGet2(_lastSig, this),
-			lastAt: _classPrivateFieldGet2(_lastAt, this)
-		});
+		this.state.batchDepth++;
+		if (this.state.batchDepth === 1) this.state.batchSnapshot = {
+			query: this.state.query,
+			past: [...this.state.past],
+			future: [...this.state.future],
+			lastSig: this.state.lastSig,
+			lastAt: this.state.lastAt
+		};
 		try {
 			fn();
 		} catch (error) {
-			if (_classPrivateFieldGet2(_batchDepth, this) === 1) {
-				const snapshot = _classPrivateFieldGet2(_batchSnapshot, this);
-				_classPrivateFieldSet2(_query, this, snapshot.query);
-				_classPrivateFieldSet2(_past, this, snapshot.past);
-				_classPrivateFieldSet2(_future, this, snapshot.future);
-				_classPrivateFieldSet2(_lastSig, this, snapshot.lastSig);
-				_classPrivateFieldSet2(_lastAt, this, snapshot.lastAt);
-				_assertClassBrand(_QueryManager_brand, this, _reconcileHistoryConfig).call(this);
+			if (this.state.batchDepth === 1) {
+				const snapshot = this.state.batchSnapshot;
+				this.state.query = snapshot.query;
+				this.state.past = snapshot.past;
+				this.state.future = snapshot.future;
+				this.state.lastSig = snapshot.lastSig;
+				this.state.lastAt = snapshot.lastAt;
+				this.reconcileHistoryConfig();
 			}
 			throw error;
 		} finally {
-			var _this$batchDepth3;
-			_classPrivateFieldSet2(_batchDepth, this, (_this$batchDepth3 = _classPrivateFieldGet2(_batchDepth, this), _this$batchDepth3--, _this$batchDepth3));
-			if (_classPrivateFieldGet2(_batchDepth, this) === 0) {
-				const { query: base } = _classPrivateFieldGet2(_batchSnapshot, this);
-				_classPrivateFieldSet2(_batchSnapshot, this, void 0);
-				if (base !== _classPrivateFieldGet2(_query, this)) {
-					if (!_classPrivateFieldGet2(_historyBypassed, this)) _assertClassBrand(_QueryManager_brand, this, _record).call(this, base, _classPrivateFieldGet2(_query, this));
-					_assertClassBrand(_QueryManager_brand, this, _notify).call(this);
+			this.state.batchDepth--;
+			if (this.state.batchDepth === 0) {
+				const { query: base } = this.state.batchSnapshot;
+				this.state.batchSnapshot = void 0;
+				const queryChanged = base !== this.state.query;
+				const configChanged = this.state.pendingConfigNotify;
+				this.state.pendingConfigNotify = false;
+				if (queryChanged) {
+					if (!this.state.historyBypassed) this.record(base, this.state.query);
 				}
-				_classPrivateFieldSet2(_historyBypassed, this, false);
+				if (queryChanged || configChanged) this.notify(queryChanged ? configChanged ? queryAndConfigChange : queryChange : configChange);
+				this.state.historyBypassed = false;
 			}
 		}
 		return this;
 	}
 	/** Whether there is a previous query to restore. Always `false` unless `history` is enabled. */
 	canUndo() {
-		return _classPrivateFieldGet2(_past, this).length > 0;
+		return this.state.past.length > 0;
 	}
 	/** Whether there is an undone query to restore. Always `false` unless `history` is enabled. */
 	canRedo() {
-		return _classPrivateFieldGet2(_future, this).length > 0;
+		return this.state.future.length > 0;
 	}
 	/** Restores the previous query. No-op when {@link QueryManager.canUndo} is `false`. */
 	undo() {
-		if (_classPrivateFieldGet2(_past, this).length === 0) return this;
-		_classPrivateFieldGet2(_future, this).unshift(_classPrivateFieldGet2(_query, this));
-		_classPrivateFieldSet2(_query, this, _classPrivateFieldGet2(_past, this).pop());
-		_classPrivateFieldSet2(_lastSig, this, void 0);
-		_assertClassBrand(_QueryManager_brand, this, _markHistoryBypassed).call(this);
-		if (_classPrivateFieldGet2(_batchDepth, this) === 0) _assertClassBrand(_QueryManager_brand, this, _notify).call(this);
+		if (this.state.past.length === 0) return this;
+		this.state.future.unshift(this.state.query);
+		this.state.query = this.state.past.pop();
+		this.state.lastSig = void 0;
+		this.markHistoryBypassed();
+		if (this.state.batchDepth === 0) this.notify(queryChange);
 		return this;
 	}
 	/** Restores the most recently undone query. No-op when {@link QueryManager.canRedo} is `false`. */
 	redo() {
-		if (_classPrivateFieldGet2(_future, this).length === 0) return this;
-		_classPrivateFieldGet2(_past, this).push(_classPrivateFieldGet2(_query, this));
-		_classPrivateFieldSet2(_query, this, _classPrivateFieldGet2(_future, this).shift());
-		_classPrivateFieldSet2(_lastSig, this, void 0);
-		_assertClassBrand(_QueryManager_brand, this, _markHistoryBypassed).call(this);
-		if (_classPrivateFieldGet2(_batchDepth, this) === 0) _assertClassBrand(_QueryManager_brand, this, _notify).call(this);
+		if (this.state.future.length === 0) return this;
+		this.state.past.push(this.state.query);
+		this.state.query = this.state.future.shift();
+		this.state.lastSig = void 0;
+		this.markHistoryBypassed();
+		if (this.state.batchDepth === 0) this.notify(queryChange);
 		return this;
 	}
 	/** Discards all undo/redo history without changing the current query. */
 	clearHistory() {
-		_assertClassBrand(_QueryManager_brand, this, _markHistoryBypassed).call(this);
-		_classPrivateFieldSet2(_past, this, []);
-		_classPrivateFieldSet2(_future, this, []);
-		_classPrivateFieldSet2(_lastSig, this, void 0);
+		this.markHistoryBypassed();
+		this.state.past = [];
+		this.state.future = [];
+		this.state.lastSig = void 0;
 		return this;
 	}
 	/**
@@ -7264,8 +8310,8 @@ var QueryManager = class QueryManager {
 	*/
 	getHistory() {
 		return {
-			past: [..._classPrivateFieldGet2(_past, this)],
-			future: [..._classPrivateFieldGet2(_future, this)]
+			past: [...this.state.past],
+			future: [...this.state.future]
 		};
 	}
 	/**
@@ -7275,13 +8321,13 @@ var QueryManager = class QueryManager {
 	* one that depends on anything other than the query) may run fewer times than expected.
 	*/
 	validate() {
-		var _classPrivateFieldGet6;
-		_assertClassBrand(_QueryManager_brand, this, _ensureCache).call(this);
-		(_classPrivateFieldGet6 = _classPrivateFieldGet2(_validation, this)) !== null && _classPrivateFieldGet6 !== void 0 || _classPrivateFieldSet2(_validation, this, _classPrivateFieldGet2(_validator, this).call(this, _classPrivateFieldGet2(_query, this)));
-		return _classPrivateFieldGet2(_validation, this);
+		var _this$state, _this$state$validatio;
+		this.ensureCache();
+		(_this$state$validatio = (_this$state = this.state).validation) !== null && _this$state$validatio !== void 0 || (_this$state.validation = this.state.validator(this.state.query));
+		return this.state.validation;
 	}
 	format(options) {
-		return formatQuery(_classPrivateFieldGet2(_query, this), options);
+		return formatQuery(this.state.query, options);
 	}
 	/**
 	* Yields every rule and group in the query, depth-first in pre-order, starting with the root
@@ -7301,18 +8347,18 @@ var QueryManager = class QueryManager {
 	*/
 	*walk(options = {}) {
 		const { from, rulesOnly, groupsOnly } = options;
-		let start = _classPrivateFieldGet2(_query, this);
+		let start = this.state.query;
 		let startPath = [];
 		let startParent = null;
 		if (from !== void 0) {
-			const path = _assertClassBrand(_QueryManager_brand, this, _toPath).call(this, from);
-			const node = path && findPath(path, _classPrivateFieldGet2(_query, this));
+			const path = this.toPath(from);
+			const node = path && findPath(path, this.state.query);
 			if (!path || !node) return;
 			start = node;
 			startPath = path;
-			startParent = path.length === 0 ? null : findPath(getParentPath(path), _classPrivateFieldGet2(_query, this));
+			startParent = path.length === 0 ? null : findPath(getParentPath(path), this.state.query);
 		}
-		for (const entry of _assertClassBrand(_QueryManager_brand, this, _walkFrom).call(this, start, startPath, startParent)) {
+		for (const entry of this.walkFrom(start, startPath, startParent)) {
 			if (rulesOnly && isRuleGroup(entry.node)) continue;
 			if (groupsOnly && !isRuleGroup(entry.node)) continue;
 			yield entry;
@@ -7352,15 +8398,15 @@ var QueryManager = class QueryManager {
 	*/
 	findPath(path) {
 		var _findPath;
-		return (_findPath = findPath(path, _classPrivateFieldGet2(_query, this))) !== null && _findPath !== void 0 ? _findPath : null;
+		return (_findPath = findPath(path, this.state.query)) !== null && _findPath !== void 0 ? _findPath : null;
 	}
 	/**
 	* Returns the rule or group with the given `id`, or `null` if there is none. Backed by an
 	* index built once per query, so repeated lookups are constant time.
 	*/
 	findID(id) {
-		const path = _assertClassBrand(_QueryManager_brand, this, _index).call(this).get(id);
-		return path === void 0 ? null : findPath(path, _classPrivateFieldGet2(_query, this));
+		const path = this.index().get(id);
+		return path === void 0 ? null : findPath(path, this.state.query);
 	}
 	/**
 	* Returns the {@link Path} of the rule or group with the given `id`, or `null` if there is
@@ -7368,20 +8414,20 @@ var QueryManager = class QueryManager {
 	*/
 	getPathOfID(id) {
 		var _this$index$get2;
-		return (_this$index$get2 = _assertClassBrand(_QueryManager_brand, this, _index).call(this).get(id)) !== null && _this$index$get2 !== void 0 ? _this$index$get2 : null;
+		return (_this$index$get2 = this.index().get(id)) !== null && _this$index$get2 !== void 0 ? _this$index$get2 : null;
 	}
 	/**
 	* Determines whether the rule or group at the given path is disabled, either itself or by an
 	* ancestor group.
 	*/
 	pathIsDisabled(path) {
-		return pathIsDisabled(path, _classPrivateFieldGet2(_query, this));
+		return pathIsDisabled(path, this.state.query);
 	}
 	/** Returns the rule or group at the given path or `id`, or `null` if it can't be resolved. */
 	getNode(pathOrID) {
 		var _findPath2;
-		const path = _assertClassBrand(_QueryManager_brand, this, _toPath).call(this, pathOrID);
-		return path === null ? null : (_findPath2 = findPath(path, _classPrivateFieldGet2(_query, this))) !== null && _findPath2 !== void 0 ? _findPath2 : null;
+		const path = this.toPath(pathOrID);
+		return path === null ? null : (_findPath2 = findPath(path, this.state.query)) !== null && _findPath2 !== void 0 ? _findPath2 : null;
 	}
 	/**
 	* Returns the rule at the given path or `id`, or `null` if it can't be resolved _or_ resolves
@@ -7404,24 +8450,24 @@ var QueryManager = class QueryManager {
 	* for the root group, which has no parent, and when the target can't be resolved.
 	*/
 	getParent(pathOrID) {
-		const path = _assertClassBrand(_QueryManager_brand, this, _toPath).call(this, pathOrID);
+		const path = this.toPath(pathOrID);
 		if (path === null || path.length === 0) return null;
-		if (!findPath(path, _classPrivateFieldGet2(_query, this))) return null;
-		return findPath(getParentPath(path), _classPrivateFieldGet2(_query, this));
+		if (!findPath(path, this.state.query)) return null;
+		return findPath(getParentPath(path), this.state.query);
 	}
 	/**
 	* The normalized field list, as the `QueryBuilder` component would render it. Needed to
 	* populate a field selector.
 	*/
 	getFields() {
-		return _classPrivateFieldGet2(_fields, this);
+		return this.state.fields;
 	}
 	/**
 	* The normalized combinator list, as the `QueryBuilder` component would render it. Needed to
 	* populate a combinator selector.
 	*/
 	getCombinators() {
-		return _classPrivateFieldGet2(_combinators, this);
+		return this.state.combinators;
 	}
 	/**
 	* The field configuration for a field name. When the field isn't configured, returns the same
@@ -7429,27 +8475,51 @@ var QueryManager = class QueryManager {
 	* {@link QueryManager.getRuleContext} reports as `fieldData`, so both access paths agree.
 	*/
 	getFieldData(field) {
-		return getFieldData(field, _classPrivateFieldGet2(_fieldMap, this));
+		return getFieldData(field, this.state.fieldMap);
 	}
 	/** The operator list for a field, mirroring `QueryBuilder`'s precedence. */
 	getOperators(field) {
-		return _assertClassBrand(_QueryManager_brand, this, _operatorsFor).call(this, field);
+		return this.operatorsFor(field);
 	}
 	/** The value sources available for a field/operator pair. */
 	getValueSources(field, operator) {
-		return _assertClassBrand(_QueryManager_brand, this, _valueSourcesFor).call(this, field, operator);
+		return this.valueSourcesFor(field, operator);
 	}
 	/** The match modes available for a field. */
 	getMatchModes(field) {
-		return _assertClassBrand(_QueryManager_brand, this, _matchModesFor).call(this, field);
+		return this.matchModesFor(field);
 	}
 	/** The value option list for a field/operator pair. */
 	getValues(field, operator) {
-		return _assertClassBrand(_QueryManager_brand, this, _valuesFor).call(this, field, operator);
+		return this.valuesFor(field, operator);
 	}
 	/** The value editor type for a field/operator pair. */
 	getValueEditorType(field, operator) {
-		return _assertClassBrand(_QueryManager_brand, this, _valueEditorTypeFor).call(this, field, operator);
+		return this.valueEditorTypeFor(field, operator);
+	}
+	/**
+	* The default `operator` for a field, identical to the operator
+	* {@link QueryManager.createRule} would assign to a new rule on that field.
+	*/
+	getRuleDefaultOperator(field) {
+		return this.defaultOperator(field);
+	}
+	/**
+	* The default `value` for a rule, identical to the value {@link QueryManager.createRule} and
+	* {@link QueryManager.update} would assign after a field or operator change.
+	*/
+	getRuleDefaultValue(rule) {
+		return this.defaultValue(rule);
+	}
+	/**
+	* The flattened field record backing {@link QueryManager.getFieldData}, keyed by field name
+	* with option groups flattened away.
+	*
+	* Treat the result as read-only. It may or may not be frozen depending on configuration, so
+	* do not rely on frozen-ness to prevent mutation.
+	*/
+	getFieldMap() {
+		return this.state.fieldMap;
 	}
 	/**
 	* Resolves everything about a rule that depends on the field/operator configuration—field data,
@@ -7464,21 +8534,21 @@ var QueryManager = class QueryManager {
 		if (!rule) return null;
 		const validation = this.validate();
 		return deriveRuleContext(rule, {
-			fields: _classPrivateFieldGet2(_fields, this),
-			fieldMap: _classPrivateFieldGet2(_fieldMap, this),
+			fields: this.state.fields,
+			fieldMap: this.state.fieldMap,
 			getInputType: (f, o, misc) => {
-				var _this$options$getInpu, _classPrivateFieldGet7, _classPrivateFieldGet8;
-				return (_this$options$getInpu = (_classPrivateFieldGet7 = (_classPrivateFieldGet8 = _classPrivateFieldGet2(_options, this)).getInputType) === null || _classPrivateFieldGet7 === void 0 ? void 0 : _classPrivateFieldGet7.call(_classPrivateFieldGet8, f, o, misc)) !== null && _this$options$getInpu !== void 0 ? _this$options$getInpu : null;
+				var _this$state$options$g3, _this$state$options$g4, _this$state$options2;
+				return (_this$state$options$g3 = (_this$state$options$g4 = (_this$state$options2 = this.state.options).getInputType) === null || _this$state$options$g4 === void 0 ? void 0 : _this$state$options$g4.call(_this$state$options2, f, o, misc)) !== null && _this$state$options$g3 !== void 0 ? _this$state$options$g3 : null;
 			},
-			getMatchModes: (f) => _assertClassBrand(_QueryManager_brand, this, _matchModesFor).call(this, f),
-			getOperators: (f) => _assertClassBrand(_QueryManager_brand, this, _operatorsFor).call(this, f),
-			getParameters: (f, o, misc) => _assertClassBrand(_QueryManager_brand, this, _parametersFor).call(this, f, o, misc),
-			getValueEditorType: (f, o) => _assertClassBrand(_QueryManager_brand, this, _valueEditorTypeFor).call(this, f, o),
-			getValues: (f, o) => _assertClassBrand(_QueryManager_brand, this, _valuesFor).call(this, f, o),
+			getMatchModes: (f) => this.matchModesFor(f),
+			getOperators: (f) => this.operatorsFor(f),
+			getParameters: (f, o, misc) => this.parametersFor(f, o, misc),
+			getValueEditorType: (f, o) => this.valueEditorTypeFor(f, o),
+			getValues: (f, o) => this.valuesFor(f, o),
 			getValueSources: (f, o) => this.getValueSources(f, o),
 			getSubQueryBuilderProps: (f, misc) => {
-				var _this$options$getSubQ, _classPrivateFieldGet9, _classPrivateFieldGet10;
-				return (_this$options$getSubQ = (_classPrivateFieldGet9 = (_classPrivateFieldGet10 = _classPrivateFieldGet2(_options, this)).getSubQueryBuilderProps) === null || _classPrivateFieldGet9 === void 0 ? void 0 : _classPrivateFieldGet9.call(_classPrivateFieldGet10, f, misc)) !== null && _this$options$getSubQ !== void 0 ? _this$options$getSubQ : {};
+				var _this$state$options$g5, _this$state$options$g6, _this$state$options3;
+				return (_this$state$options$g5 = (_this$state$options$g6 = (_this$state$options3 = this.state.options).getSubQueryBuilderProps) === null || _this$state$options$g6 === void 0 ? void 0 : _this$state$options$g6.call(_this$state$options3, f, misc)) !== null && _this$state$options$g5 !== void 0 ? _this$state$options$g5 : {};
 			}
 		}, {
 			validationMap: typeof validation === "boolean" ? {} : validation,
@@ -7495,32 +8565,32 @@ var QueryManager = class QueryManager {
 		const ruleGroup = this.getGroup(pathOrID);
 		if (!ruleGroup) return null;
 		const validation = this.validate();
-		return deriveRuleGroupContext(ruleGroup, _classPrivateFieldGet2(_combinators, this), {
+		return deriveRuleGroupContext(ruleGroup, this.state.combinators, {
 			validationMap: typeof validation === "boolean" ? {} : validation,
 			id: ruleGroup.id
 		});
 	}
 	/** Whether the current query uses independent combinators. */
 	isIC() {
-		return isRuleGroupTypeIC(_classPrivateFieldGet2(_query, this));
+		return isRuleGroupTypeIC(this.state.query);
 	}
 	/**
 	* Returns the signature describing how the current query differs from `other`, as used by
 	* this manager's history coalescing.
 	*/
 	signatureOf(other) {
-		return signatureOf(_classPrivateFieldGet2(_query, this), other);
+		return signatureOf(this.state.query, other);
 	}
 	/** Generates a {@link DiagnosticsResult}. Shorthand for `format('diagnostics')`. */
 	diagnostics() {
-		return formatQuery(_classPrivateFieldGet2(_query, this), "diagnostics");
+		return formatQuery(this.state.query, "diagnostics");
 	}
 	/**
 	* Returns the current query, so `JSON.stringify(queryManager)` produces the same output as
 	* `JSON.stringify(queryManager.getQuery())`.
 	*/
 	toJSON() {
-		return _classPrivateFieldGet2(_query, this);
+		return this.state.query;
 	}
 	/**
 	* Returns a new manager with the same configuration and the current query converted to use
@@ -7528,7 +8598,7 @@ var QueryManager = class QueryManager {
 	* {@link QueryManager.clone}, subscribers and history are not carried over.
 	*/
 	toIC() {
-		return new QueryManager(convertToIC(_classPrivateFieldGet2(_query, this)), _classPrivateFieldGet2(_options, this));
+		return new QueryManager(convertToIC(this.state.query), this.state.options);
 	}
 	/**
 	* Returns a new manager with the same configuration and the current query converted to use a
@@ -7536,7 +8606,7 @@ var QueryManager = class QueryManager {
 	* {@link QueryManager.clone}, subscribers and history are not carried over.
 	*/
 	fromIC() {
-		return new QueryManager(convertFromIC(_classPrivateFieldGet2(_query, this)), _classPrivateFieldGet2(_options, this));
+		return new QueryManager(convertFromIC(this.state.query), this.state.options);
 	}
 	/**
 	* Runs {@link transformQuery} against the current query and returns its result.
@@ -7546,270 +8616,10 @@ var QueryManager = class QueryManager {
 	* shapes that are no longer valid queries. This manager is never modified.
 	*/
 	transform(options) {
-		return transformQuery(_classPrivateFieldGet2(_query, this), options);
-	}
-};
-/**
-* Assigns `#options` and every field derived from it. Shared by the constructor and
-* {@link QueryManager.reconfigure}, so the two can never drift apart. Does not touch the
-* query, the history stacks, the caches, or the subscriber list.
-*/
-function _applyOptions(options) {
-	var _options$idGenerator, _options$validator, _options$strict, _options$respectDisab, _options$history, _historyOptions$maxHi, _historyOptions$coale, _options$now, _options$translations, _options$operators, _options$translations2, _options$combinators;
-	_classPrivateFieldSet2(_options, this, options);
-	_classPrivateFieldSet2(_idGenerator, this, (_options$idGenerator = options.idGenerator) !== null && _options$idGenerator !== void 0 ? _options$idGenerator : generateID);
-	_classPrivateFieldSet2(_validator, this, (_options$validator = options.validator) !== null && _options$validator !== void 0 ? _options$validator : defaultValidator);
-	_classPrivateFieldSet2(_strict, this, (_options$strict = options.strict) !== null && _options$strict !== void 0 ? _options$strict : false);
-	_classPrivateFieldSet2(_respectDisabled, this, (_options$respectDisab = options.respectDisabled) !== null && _options$respectDisab !== void 0 ? _options$respectDisab : true);
-	_classPrivateFieldSet2(_onInvalidTarget, this, options.onInvalidTarget);
-	const history = (_options$history = options.history) !== null && _options$history !== void 0 ? _options$history : false;
-	const historyOptions = typeof history === "object" ? history : {};
-	_classPrivateFieldSet2(_historyEnabled, this, history !== false);
-	_classPrivateFieldSet2(_maxHistory, this, (_historyOptions$maxHi = historyOptions.maxHistory) !== null && _historyOptions$maxHi !== void 0 ? _historyOptions$maxHi : 50);
-	_classPrivateFieldSet2(_coalesceMs, this, (_historyOptions$coale = historyOptions.coalesceMs) !== null && _historyOptions$coale !== void 0 ? _historyOptions$coale : 500);
-	_classPrivateFieldSet2(_now, this, (_options$now = options.now) !== null && _options$now !== void 0 ? _options$now : Date.now);
-	const { optionList: fields, optionsMap: fieldMap } = prepareOptionList({
-		optionList: options.fields,
-		baseOption: options.baseField,
-		autoSelectOption: options.autoSelectField,
-		placeholder: (_options$translations = options.translations) === null || _options$translations === void 0 ? void 0 : _options$translations.fields
-	});
-	_classPrivateFieldSet2(_fields, this, freeze(fields, true));
-	_classPrivateFieldSet2(_fieldMap, this, freeze(fieldMap, true));
-	_classPrivateFieldSet2(_operators, this, prepareOptionList({
-		optionList: (_options$operators = options.operators) !== null && _options$operators !== void 0 ? _options$operators : defaultOperators,
-		baseOption: options.baseOperator,
-		labelMap: defaultOperatorLabelMap,
-		autoSelectOption: options.autoSelectOperator,
-		placeholder: (_options$translations2 = options.translations) === null || _options$translations2 === void 0 ? void 0 : _options$translations2.operators
-	}).optionList);
-	_classPrivateFieldSet2(_combinators, this, freeze(prepareOptionList({
-		optionList: (_options$combinators = options.combinators) !== null && _options$combinators !== void 0 ? _options$combinators : defaultCombinators,
-		baseOption: options.baseCombinator
-	}).optionList, true));
-}
-/** Resolves the field configuration for a field name. */
-function _fieldData(field) {
-	var _this$fieldMap$field;
-	return (_this$fieldMap$field = _classPrivateFieldGet2(_fieldMap, this)[field]) !== null && _this$fieldMap$field !== void 0 ? _this$fieldMap$field : {};
-}
-/** Resolves the operator list for a field, mirroring `QueryBuilder`'s precedence. */
-function _operatorsFor(field) {
-	var _classPrivateFieldGet2$1;
-	return resolveOperatorList({
-		field,
-		fieldData: _assertClassBrand(_QueryManager_brand, this, _fieldData).call(this, field),
-		getOperators: _classPrivateFieldGet2(_options, this).getOperators,
-		operators: _classPrivateFieldGet2(_operators, this),
-		baseOption: _classPrivateFieldGet2(_options, this).baseOperator,
-		autoSelectOption: _classPrivateFieldGet2(_options, this).autoSelectOperator,
-		placeholder: (_classPrivateFieldGet2$1 = _classPrivateFieldGet2(_options, this).translations) === null || _classPrivateFieldGet2$1 === void 0 ? void 0 : _classPrivateFieldGet2$1.operators
-	});
-}
-/** Resolves the default operator for a field, mirroring `QueryBuilder`'s precedence. */
-function _defaultOperator(field) {
-	return resolveDefaultOperator({
-		field,
-		fieldData: _assertClassBrand(_QueryManager_brand, this, _fieldData).call(this, field),
-		getDefaultOperator: _classPrivateFieldGet2(_options, this).getDefaultOperator,
-		getOperators: (f) => _assertClassBrand(_QueryManager_brand, this, _operatorsFor).call(this, f)
-	});
-}
-function _valueSourcesFor(field, operator) {
-	return getValueSourcesUtil(_assertClassBrand(_QueryManager_brand, this, _fieldData).call(this, field), operator, _classPrivateFieldGet2(_options, this).getValueSources);
-}
-function _matchModesFor(field) {
-	return getMatchModesUtil(_assertClassBrand(_QueryManager_brand, this, _fieldData).call(this, field), _classPrivateFieldGet2(_options, this).getMatchModes);
-}
-function _valuesFor(field, operator) {
-	var _classPrivateFieldGet3;
-	return resolveValueList({
-		field,
-		operator,
-		fieldData: _assertClassBrand(_QueryManager_brand, this, _fieldData).call(this, field),
-		getValues: _classPrivateFieldGet2(_options, this).getValues,
-		autoSelectOption: _classPrivateFieldGet2(_options, this).autoSelectValue,
-		placeholder: (_classPrivateFieldGet3 = _classPrivateFieldGet2(_options, this).translations) === null || _classPrivateFieldGet3 === void 0 ? void 0 : _classPrivateFieldGet3.values
-	});
-}
-function _valueEditorTypeFor(field, operator) {
-	return resolveValueEditorType({
-		field,
-		operator,
-		fieldData: _assertClassBrand(_QueryManager_brand, this, _fieldData).call(this, field),
-		getValueEditorType: _classPrivateFieldGet2(_options, this).getValueEditorType
-	});
-}
-/** Computes the default `value` for a rule, mirroring `QueryBuilder`'s precedence. */
-function _defaultValue(rule) {
-	const { getDefaultValue, getParameters, listsAsArrays } = _classPrivateFieldGet2(_options, this);
-	return getRuleDefaultValue(rule, {
-		fieldData: _assertClassBrand(_QueryManager_brand, this, _fieldData).call(this, rule.field),
-		fields: _classPrivateFieldGet2(_fields, this),
-		listsAsArrays,
-		getValueEditorType: (f, o) => _assertClassBrand(_QueryManager_brand, this, _valueEditorTypeFor).call(this, f, o),
-		getValues: (f, o) => _assertClassBrand(_QueryManager_brand, this, _valuesFor).call(this, f, o),
-		getDefaultValue: getDefaultValue && ((r, misc) => getDefaultValue(r, misc)),
-		getParameters: getParameters && ((f, o, misc) => _assertClassBrand(_QueryManager_brand, this, _parametersFor).call(this, f, o, misc))
-	});
-}
-/**
-* Resolves the parameter list for a field/operator pair, normalized the same way as every
-* other option list. Shared by {@link QueryManager.#defaultValue} and
-* {@link QueryManager.getRuleContext} so both see the same shape.
-*/
-function _parametersFor(field, operator, misc) {
-	var _this$options$getPara, _classPrivateFieldGet4, _classPrivateFieldGet5;
-	return prepareOptionList({
-		optionList: (_this$options$getPara = (_classPrivateFieldGet4 = (_classPrivateFieldGet5 = _classPrivateFieldGet2(_options, this)).getParameters) === null || _classPrivateFieldGet4 === void 0 ? void 0 : _classPrivateFieldGet4.call(_classPrivateFieldGet5, field, operator, misc)) !== null && _this$options$getPara !== void 0 ? _this$options$getPara : [],
-		autoSelectOption: _classPrivateFieldGet2(_options, this).autoSelectValue
-	}).optionList;
-}
-/** Defaults shared by every mutating method, overridable per call. */
-function _guardOptions() {
-	const { maxLevels } = _classPrivateFieldGet2(_options, this);
-	return {
-		maxLevels: (maxLevels !== null && maxLevels !== void 0 ? maxLevels : 0) > 0 ? Number(maxLevels) : Infinity,
-		respectDisabled: _classPrivateFieldGet2(_respectDisabled, this),
-		disabledPaths: _classPrivateFieldGet2(_options, this).disabledPaths,
-		queryDisabled: _classPrivateFieldGet2(_options, this).queryDisabled
-	};
-}
-function _toolOptions() {
-	return _objectSpread2({
-		combinators: _classPrivateFieldGet2(_combinators, this),
-		idGenerator: _classPrivateFieldGet2(_idGenerator, this)
-	}, _assertClassBrand(_QueryManager_brand, this, _guardOptions).call(this));
-}
-/**
-* Builds the `onAbort` handler passed to the query tools, applying the per-call overrides on
-* top of the manager's own options.
-*/
-function _onAbort({ strict, onInvalidTarget }) {
-	const strictMain = strict !== null && strict !== void 0 ? strict : _classPrivateFieldGet2(_strict, this);
-	const handler = onInvalidTarget !== null && onInvalidTarget !== void 0 ? onInvalidTarget : _classPrivateFieldGet2(_onInvalidTarget, this);
-	return (info) => {
-		handler === null || handler === void 0 || handler(info);
-		if (strictMain && strictAbortReasonSet.has(info.reason)) throw new QueryManagerError(info);
-	};
-}
-/** Defaults for {@link update}, so resets mirror `QueryBuilder`'s behavior. */
-function _updateOptions() {
-	return _objectSpread2({
-		getRuleDefaultOperator: (f) => _assertClassBrand(_QueryManager_brand, this, _defaultOperator).call(this, f),
-		getRuleDefaultValue: (r) => _assertClassBrand(_QueryManager_brand, this, _defaultValue).call(this, r),
-		getValueSources: (f, o) => _assertClassBrand(_QueryManager_brand, this, _valueSourcesFor).call(this, f, o),
-		getMatchModes: (f) => _assertClassBrand(_QueryManager_brand, this, _matchModesFor).call(this, f),
-		resetOnFieldChange: _classPrivateFieldGet2(_options, this).resetOnFieldChange,
-		resetOnOperatorChange: _classPrivateFieldGet2(_options, this).resetOnOperatorChange
-	}, _assertClassBrand(_QueryManager_brand, this, _guardOptions).call(this));
-}
-/**
-* Applies a new query, recording history and notifying subscribers as appropriate. Every
-* mutation funnels through here. A tool that could not resolve its target returns the same
-* query object, which is treated as a no-op.
-*/
-function _commit(next) {
-	const prev = _classPrivateFieldGet2(_query, this);
-	if (prev === next) return;
-	_classPrivateFieldSet2(_query, this, next);
-	if (_classPrivateFieldGet2(_batchDepth, this) > 0) return;
-	_assertClassBrand(_QueryManager_brand, this, _record).call(this, prev, next);
-	_assertClassBrand(_QueryManager_brand, this, _notify).call(this);
-}
-/**
-* Records a change, either as a new history entry or by absorbing it into the current one.
-* Mirrors the recording semantics of the `react-querybuilder/history` entry point.
-*/
-function _record(prev, next) {
-	if (!_classPrivateFieldGet2(_historyEnabled, this)) return;
-	const sig = signatureOf(prev, next);
-	if (sig === "") return;
-	const now = _classPrivateFieldGet2(_now, this).call(this);
-	if (!(sig !== "~structural" && sig === _classPrivateFieldGet2(_lastSig, this) && now - _classPrivateFieldGet2(_lastAt, this) < _classPrivateFieldGet2(_coalesceMs, this))) {
-		_classPrivateFieldGet2(_past, this).push(prev);
-		if (_classPrivateFieldGet2(_past, this).length > _classPrivateFieldGet2(_maxHistory, this)) _classPrivateFieldGet2(_past, this).shift();
-		_classPrivateFieldSet2(_future, this, []);
-	}
-	_classPrivateFieldSet2(_lastSig, this, sig);
-	_classPrivateFieldSet2(_lastAt, this, now);
-}
-function _notify() {
-	for (const listener of _classPrivateFieldGet2(_listeners, this)) listener();
-}
-/**
-* Records that a history-stack method ran inside the current batch. Those methods manage
-* `#past`/`#future` themselves, so the batch must not also record an entry on completion —
-* doing so would push a duplicate onto `#past` and clear the redo stack that `undo` just
-* populated.
-*/
-function _markHistoryBypassed() {
-	if (_classPrivateFieldGet2(_batchDepth, this) > 0) _classPrivateFieldSet2(_historyBypassed, this, true);
-}
-/**
-* Discards every cached derivation when the query has been replaced since they were computed.
-* Called at the top of each cached reader.
-*/
-function _ensureCache() {
-	if (_classPrivateFieldGet2(_cacheFor, this) === _classPrivateFieldGet2(_query, this)) return;
-	_classPrivateFieldSet2(_cacheFor, this, _classPrivateFieldGet2(_query, this));
-	_classPrivateFieldSet2(_idPathIndex, this, void 0);
-	_classPrivateFieldSet2(_validation, this, void 0);
-}
-/**
-* The single traversal implementation. Combinator strings in independent-combinator groups
-* are skipped.
-*
-* @yields The subtree rooted at `node`, depth-first in pre-order, starting with `node` itself.
-*/
-function* _walkFrom(node, path, parent) {
-	yield {
-		node,
-		path,
-		parent
-	};
-	if (!isRuleGroup(node)) return;
-	const startGroup = node;
-	for (const [index, child] of startGroup.rules.entries()) {
-		if (typeof child === "string") continue;
-		yield* _assertClassBrand(_QueryManager_brand, this, _walkFrom).call(this, child, [...path, index], startGroup);
-	}
-}
-/** Builds (once per query) the `id` to {@link Path} index backing `findID`/`getPathOfID`. */
-function _index() {
-	_assertClassBrand(_QueryManager_brand, this, _ensureCache).call(this);
-	if (!_classPrivateFieldGet2(_idPathIndex, this)) {
-		const index = /* @__PURE__ */ new Map();
-		for (const { node, path } of _assertClassBrand(_QueryManager_brand, this, _walkFrom).call(this, _classPrivateFieldGet2(_query, this), [], null)) if (node.id !== void 0 && !index.has(node.id)) index.set(node.id, path);
-		_classPrivateFieldSet2(_idPathIndex, this, index);
-	}
-	return _classPrivateFieldGet2(_idPathIndex, this);
-}
-/** Resolves a path or `id` to a path, or `null` when the `id` isn't present. */
-function _toPath(pathOrID) {
-	var _this$index$get;
-	return typeof pathOrID === "string" ? (_this$index$get = _assertClassBrand(_QueryManager_brand, this, _index).call(this).get(pathOrID)) !== null && _this$index$get !== void 0 ? _this$index$get : null : pathOrID;
-}
-/**
-* Brings the history stacks in line with the current history configuration. Unlike
-* {@link QueryManager.clearHistory}, this does _not_ set `#historyBypassed`: it reflects a
-* configuration change rather than a deliberate history repositioning, so a later mutation in
-* the same batch must still be recorded normally.
-*
-* Called by {@link QueryManager.reconfigure} and again after a failed
-* {@link QueryManager.batch batch} restores its snapshot, since that snapshot predates the
-* configuration change (configuration is not part of a batch's rollback).
-*/
-function _reconcileHistoryConfig() {
-	if (_classPrivateFieldGet2(_historyEnabled, this)) {
-		if (_classPrivateFieldGet2(_past, this).length > _classPrivateFieldGet2(_maxHistory, this)) _classPrivateFieldGet2(_past, this).splice(0, _classPrivateFieldGet2(_past, this).length - _classPrivateFieldGet2(_maxHistory, this));
-	} else {
-		_classPrivateFieldSet2(_past, this, []);
-		_classPrivateFieldSet2(_future, this, []);
-		_classPrivateFieldSet2(_lastSig, this, void 0);
+		return transformQuery(this.state.query, options);
 	}
-}
+};
 //#endregion
-export { LogType, QueryManager, QueryManagerError, TestID, add, addInPlace, betweenOperators, bigIntJsonParseReviver, bigIntJsonStringifyReplacer, celCombinatorMap, clsx, coerceBigIntValue, coerceInputType, convertFromIC, convertQuery, convertToIC, createQueryActions, createRule, createRuleGroup, cypherCombinatorMap, defaultCELValueProcessor, defaultCoalesceMs, defaultCombinatorLabelMap, defaultCombinators, defaultCombinatorsExtended, defaultControlClassnames, defaultExportOperatorMap, defaultJoinChar, defaultMatchModes, defaultMaxHistory, defaultMongoDBValueProcessor, defaultNLTranslations, defaultOperatorLabelMap, defaultOperatorNegationMap, defaultOperatorProcessorNL, defaultOperatorProcessorSQL, defaultOperators, defaultPlaceholderFieldGroupLabel, defaultPlaceholderFieldLabel, defaultPlaceholderFieldName, defaultPlaceholderLabel, defaultPlaceholderName, defaultPlaceholderOperatorGroupLabel, defaultPlaceholderOperatorLabel, defaultPlaceholderOperatorName, defaultPlaceholderValueGroupLabel, defaultPlaceholderValueLabel, defaultPlaceholderValueName, defaultRuleGroupProcessorCEL, defaultRuleGroupProcessorCypher, defaultRuleGroupProcessorDiagnostics, defaultRuleGroupProcessorDrizzle, defaultRuleGroupProcessorElasticSearch, defaultRuleGroupProcessorGremlin, defaultRuleGroupProcessorJSONata, defaultRuleGroupProcessorJsonLogic, defaultRuleGroupProcessorLDAP, defaultRuleGroupProcessorMongoDB, defaultRuleGroupProcessorMongoDBQuery, defaultRuleGroupProcessorNL, defaultRuleGroupProcessorParameterized, defaultRuleGroupProcessorPrisma, defaultRuleGroupProcessorSPARQL, defaultRuleGroupProcessorSQL, defaultRuleGroupProcessorSequelize, defaultRuleGroupProcessorSpEL, defaultRuleGroupProcessorTanStackDB, defaultRuleProcessorCEL, defaultRuleProcessorCypher, defaultRuleProcessorDrizzle, defaultRuleProcessorElasticSearch, defaultRuleProcessorGremlin, defaultRuleProcessorJSONata, defaultRuleProcessorJsonLogic, defaultRuleProcessorLDAP, defaultRuleProcessorMongoDB, defaultRuleProcessorMongoDBQuery, defaultRuleProcessorNL, defaultRuleProcessorParameterized, defaultRuleProcessorPrisma, defaultRuleProcessorSPARQL, defaultRuleProcessorSQL, defaultRuleProcessorSequelize, defaultRuleProcessorSpEL, defaultRuleProcessorTanStackDB, defaultSpELValueProcessor, defaultTranslations, defaultValidator, defaultValueProcessor, defaultValueProcessorByRule, defaultValueProcessorCELByRule, defaultValueProcessorMongoDBByRule, defaultValueProcessorNL, defaultValueProcessorSpELByRule, derivePathInfo, deriveQueryBuilderClassNames, deriveRuleClassName, deriveRuleClassNames, deriveRuleContext, deriveRuleGroupClassNames, deriveRuleGroupContext, deriveRuleGroupOuterClassName, deriveRuleOuterClassName, exceedsMaxLevels, filterFieldsByComparator, findID, findPath, formatQuery, formatQueryOptionPresets, generateAccessibleDescription, generateID, getCommonAncestorPath, getFieldData, getFirstOption, getGuardAbortReason, getLikeWildcards, getMatchModesUtil, getMultiValueUpdate, getNLTranslataion, getOption, getParametersAsList, getParentPath, getParseNumberMethod, getPathOfID, getQuoteFieldNamesWithArray, getQuotedFieldName, getRuleDefaultValue, getRuleGroupCombinator, getRuleInputType, getRuleValidationResult, getRuleValueEditorType, getRuleValueSourceOptions, getRuleValues, getSQLConcat, getSubqueryElementAlias, getValidationClassNames, getValueEditorReset, getValueSelectorUpdate, getValueSourcesUtil, group, groupInPlace, groupInvalidReasons, hideValueControlsForOperator, inOperators, insert, insertInPlace, isAncestor, isBetweenOperator, isFlexibleOptionArray, isFlexibleOptionGroupArray, isFullOptionArray, isFullOptionGroupArray, isOptionGroupArray, isPojo, isRuleGroup, isRuleGroupType, isRuleGroupTypeIC, isRuleOrGroupValid, isRuleType, isUnsafeKey, isValidValue, isValidationResult, isValueProcessorLegacy, joinWith, jsonLogicAdditionalOperators, lc, mapSQLOperator, mergeAnyTranslation, mergeAnyTranslations, mergeClassnames, mongoDbFallback, mongoOperators, move, moveInPlace, normalizeConstituentWordOrder, normalizeValueSelectorValue, nullFreeArray, nullOperators, nullOrUndefinedOrEmpty, numericRegex, numerifyValues, objectEntries, objectKeys, parseNumber, pathIsDisabled, pathIsDisabledByPaths, pathsAreEqual, preferAnyProp, preferFlagProps, preferProp, prepareOptionList, prepareRule, prepareRuleGroup, prepareRuleOrGroup, prismaFallback, prismaOperators, processMatchMode, queryBuilderFlagDefaults, regenerateID, regenerateIDs, relationalOperators, remove, removeInPlace, resolveCandidateQuery, resolveDefaultOperator, resolveOperatorList, resolveValueEditorType, resolveValueList, rootPath, shouldRenderAsNumber, signatureOf, sparqlVar, splitBy, sqlDialectPresets, standardClassnames, strictAbortReasons, stripParamPrefix, structuralSignature, subqueryElementAliasBase, substringOperators, toArray, toFlatOptionArray, toFullOption, toFullOptionList, toFullOptionMap, transformQuery, trimIfString, unchangedSignature, uniqByIdentifier, uniqByName, uniqOptGroups, uniqOptList, update, updateInPlace, uuidV4regex, withParamPrefix, wrapLikeFragment };
+export { LogType, QueryManager, QueryManagerError, TestID, add, addInPlace, betweenOperators, bigIntJsonParseReviver, bigIntJsonStringifyReplacer, celCombinatorMap, clsx, coerceBigIntValue, coerceInputType, controlKeys, controlKind, controlPropKeys, convertFromIC, convertQuery, convertToIC, createQueryActions, createRule, createRuleGroup, cypherCombinatorMap, defaultCELValueProcessor, defaultCoalesceMs, defaultCombinatorLabelMap, defaultCombinators, defaultCombinatorsExtended, defaultControlClassnames, defaultExportOperatorMap, defaultJoinChar, defaultMatchModes, defaultMaxHistory, defaultMongoDBValueProcessor, defaultNLTranslations, defaultOperatorLabelMap, defaultOperatorNegationMap, defaultOperatorProcessorNL, defaultOperatorProcessorSQL, defaultOperators, defaultPlaceholderFieldGroupLabel, defaultPlaceholderFieldLabel, defaultPlaceholderFieldName, defaultPlaceholderLabel, defaultPlaceholderName, defaultPlaceholderOperatorGroupLabel, defaultPlaceholderOperatorLabel, defaultPlaceholderOperatorName, defaultPlaceholderValueGroupLabel, defaultPlaceholderValueLabel, defaultPlaceholderValueName, defaultRuleGroupProcessorCEL, defaultRuleGroupProcessorCypher, defaultRuleGroupProcessorDiagnostics, defaultRuleGroupProcessorDrizzle, defaultRuleGroupProcessorElasticSearch, defaultRuleGroupProcessorGremlin, defaultRuleGroupProcessorJSONata, defaultRuleGroupProcessorJsonLogic, defaultRuleGroupProcessorLDAP, defaultRuleGroupProcessorMongoDB, defaultRuleGroupProcessorMongoDBQuery, defaultRuleGroupProcessorNL, defaultRuleGroupProcessorParameterized, defaultRuleGroupProcessorPrisma, defaultRuleGroupProcessorSPARQL, defaultRuleGroupProcessorSQL, defaultRuleGroupProcessorSequelize, defaultRuleGroupProcessorSpEL, defaultRuleGroupProcessorTanStackDB, defaultRuleProcessorCEL, defaultRuleProcessorCypher, defaultRuleProcessorDrizzle, defaultRuleProcessorElasticSearch, defaultRuleProcessorGremlin, defaultRuleProcessorJSONata, defaultRuleProcessorJsonLogic, defaultRuleProcessorLDAP, defaultRuleProcessorMongoDB, defaultRuleProcessorMongoDBQuery, defaultRuleProcessorNL, defaultRuleProcessorParameterized, defaultRuleProcessorPrisma, defaultRuleProcessorSPARQL, defaultRuleProcessorSQL, defaultRuleProcessorSequelize, defaultRuleProcessorSpEL, defaultRuleProcessorTanStackDB, defaultSpELValueProcessor, defaultTranslations, defaultValidator, defaultValueProcessor, defaultValueProcessorByRule, defaultValueProcessorCELByRule, defaultValueProcessorMongoDBByRule, defaultValueProcessorNL, defaultValueProcessorSpELByRule, derivePathInfo, deriveQueryBuilderClassNames, deriveRuleClassName, deriveRuleClassNames, deriveRuleContext, deriveRuleGroupClassNames, deriveRuleGroupContext, deriveRuleGroupOuterClassName, deriveRuleOuterClassName, exceedsMaxLevels, filterFieldsByComparator, findID, findPath, formatQuery, formatQueryOptionPresets, generateAccessibleDescription, generateID, getCommonAncestorPath, getFieldData, getFirstOption, getGuardAbortReason, getLikeWildcards, getMatchModesUtil, getMultiValueUpdate, getNLTranslataion, getOption, getParametersAsList, getParentPath, getParseNumberMethod, getPathOfID, getQuoteFieldNamesWithArray, getQuotedFieldName, getRuleDefaultValue, getRuleGroupCombinator, getRuleInputType, getRuleValidationResult, getRuleValueEditorType, getRuleValueSourceOptions, getRuleValues, getSQLConcat, getSubqueryElementAlias, getValidationClassNames, getValueEditorReset, getValueSelectorUpdate, getValueSourcesUtil, group, groupInPlace, groupInvalidReasons, hideValueControlsForOperator, inOperators, insert, insertInPlace, isAncestor, isBetweenOperator, isFlexibleOptionArray, isFlexibleOptionGroupArray, isFullOptionArray, isFullOptionGroupArray, isOptionGroupArray, isPojo, isRuleGroup, isRuleGroupType, isRuleGroupTypeIC, isRuleOrGroupValid, isRuleType, isUnsafeKey, isValidValue, isValidationResult, isValueProcessorLegacy, joinWith, jsonLogicAdditionalOperators, lc, mapSQLOperator, mergeAnyTranslation, mergeAnyTranslations, mergeClassnames, mongoDbFallback, mongoOperators, move, moveInPlace, normalizeConstituentWordOrder, normalizeValueSelectorValue, nullFreeArray, nullOperators, nullOrUndefinedOrEmpty, numericRegex, numerifyValues, objectEntries, objectKeys, optionsEqual, parseNumber, pathIsDisabled, pathIsDisabledByPaths, pathsAreEqual, preferAnyProp, preferFlagProps, preferProp, prepareOptionList, prepareRule, prepareRuleGroup, prepareRuleOrGroup, prismaFallback, prismaOperators, processMatchMode, queryBuilderFlagDefaults, regenerateID, regenerateIDs, relationalOperators, remove, removeInPlace, resolveCandidateQuery, resolveDefaultOperator, resolveOperatorList, resolveValueEditorType, resolveValueList, rootPath, setAutoFreeze, shouldCoalesce, shouldRenderAsNumber, signatureOf, sparqlVar, splitBy, sqlDialectPresets, standardClassnames, strictAbortReasons, stripParamPrefix, structuralSignature, subqueryElementAliasBase, substringOperators, toArray, toFlatOptionArray, toFullOption, toFullOptionList, toFullOptionMap, transformQuery, trimIfString, unchangedSignature, uniqByIdentifier, uniqByName, uniqOptGroups, uniqOptList, update, updateInPlace, uuidV4regex, valuesEqual, withParamPrefix, wrapLikeFragment };
 
 //# sourceMappingURL=react-querybuilder_core.legacy-esm.js.map