@react-querybuilder/core 8.22.5 → 8.23.0

package/dist/cjs/react-querybuilder_core.cjs.development.js

@@ -1,6 +1,647 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 let numeric_quantity = require("numeric-quantity");
 let immer = require("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
@@ -649,6 +1290,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
@@ -751,6 +1417,94 @@ const isRuleGroupType = (rg) => isRuleGroup(rg) && typeof rg.combinator === "str
 */
 const isRuleGroupTypeIC = (rg) => isRuleGroup(rg) && rg.combinator === void 0;
 //#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) => {
+	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) {
+		const props = changedProps(prev, next);
+		return props.length === 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) return ownProps.length === 0 ? "" : `${next.id ?? ""}:${ownProps.join(",")}`;
+	if (ownProps.length > 0) return structuralSignature;
+	return signatureOfNode(prev.rules[changedIndex], next.rules[changedIndex], next.id ?? "", 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 src/utils/convertQuery.ts
 const combinatorLevels = [
 	"or",
@@ -1264,6 +2018,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;
@@ -4562,8 +5330,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 {
@@ -5285,6 +6055,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
@@ -5323,6 +6099,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 = immer.setAutoFreeze;
+const unfrozenImmer = new immer.Immer({ autoFreeze: false });
+/**
+* The `produce` implementation matching the requested freeze behavior.
+*
+* @internal
+*/
+const producerFor = (freeze = true) => freeze ? immer.produce : unfrozenImmer.produce;
+//#endregion
 //#region src/utils/getMatchModesUtil.ts
 const dummyFD$1 = {
 	name: "name",
@@ -5575,6 +6374,46 @@ const resolveValueList = ({ field, operator, fieldData, getValues, placeholder,
 	autoSelectOption
 }).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;
@@ -5711,7 +6550,7 @@ const exceedsMaxLevels = (parentPath, { maxLevels = Infinity } = {}) => !!parent
 *
 * @group Query Tools
 */
-const add = (query, ruleOrGroup, parentPathOrID, options = {}) => (0, immer.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.
 *
@@ -5803,6 +6642,11 @@ 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) => (typeof a === "string" || Array.isArray(a) ? d : c) ?? {};
+/**
 * Applies one or more property updates to a query in place. Shared by
 * {@link update} and {@link updateInPlace}.
 */
@@ -5823,7 +6667,7 @@ const applyUpdatesInPlace = (query, a, b, c, d) => {
 *
 * @group Query Tools
 */
-const update = ((query, a, b, c, d) => (0, immer.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);
 }));
 /**
@@ -5871,13 +6715,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?.({
-			reason: "no-change",
-			operation: "update",
-			pathOrID
-		});
-		else parentRules[path.at(-1)] = value;
-		else onAbort?.({
+		if (path.at(-1) % 2 === 1) {
+			if (parentRules[path.at(-1)] === value) onAbort?.({
+				reason: "no-change",
+				operation: "update",
+				pathOrID
+			});
+			else parentRules[path.at(-1)] = value;
+		} else onAbort?.({
 			reason: "not-a-combinator-slot",
 			operation: "update",
 			pathOrID
@@ -5947,7 +6792,7 @@ const updateInPlaceSingle = (query, prop, value, pathOrID, options = {}) => {
 *
 * @group Query Tools
 */
-const remove = (query, pathOrID, options = {}) => (0, immer.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.
 *
@@ -6002,25 +6847,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;
 };
@@ -6032,7 +6880,7 @@ const getNextPath = (query, currentPath, newPathOrShiftDirection) => {
 *
 * @group Query Tools
 */
-const move = (query, oldPathOrID, newPath, options = {}) => (0, immer.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.
@@ -6128,9 +6976,10 @@ 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 insertRuleOrGroup(ruleOrGroup, parentToInsertInto.rules[1] ?? oldPrevCombinator ?? getFirstOption(combinators));
-	else if (oldPrevCombinator) insertRuleOrGroup(oldPrevCombinator, ruleOrGroup);
+	else if (newIndex === 0) {
+		if (ruleToRemoveIndex === 0 && oldNextCombinator) insertRuleOrGroup(ruleOrGroup, oldNextCombinator);
+		else insertRuleOrGroup(ruleOrGroup, parentToInsertInto.rules[1] ?? oldPrevCombinator ?? getFirstOption(combinators));
+	} else if (oldPrevCombinator) insertRuleOrGroup(oldPrevCombinator, ruleOrGroup);
 	else insertRuleOrGroup(parentToInsertInto.rules[spliceIndex - 2] ?? oldNextCombinator ?? getFirstOption(combinators), ruleOrGroup);
 	return query;
 };
@@ -6141,7 +6990,7 @@ const moveInPlace = (query, oldPathOrID, newPath, options = {}) => {
 *
 * @group Query Tools
 */
-const insert = (query, ruleOrGroup, path, options = {}) => (0, immer.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.
 *
@@ -6196,9 +7045,10 @@ const insertInPlace = (query, ruleOrGroup, path, options = {}) => {
 	const insertRuleOrGroup = (idx, ...args) => parentToInsertInto.rules.splice(idx, replace ? args.length : 0, ...args);
 	if (parentToInsertInto.rules.length === 0 || !independentCombinators) insertRuleOrGroup(newIndex, rorg);
 	else if (replace && independentCombinators) insertRuleOrGroup(newIndex + newIndex % 2, rorg);
-	else if (newIndex === 0) if (rorg.path?.at(-1) === 0 && combinatorSucceeding) insertRuleOrGroup(newIndex, rorg, combinatorSucceeding);
-	else insertRuleOrGroup(newIndex, rorg, parentToInsertInto.rules[1] ?? combinatorPreceding ?? getFirstOption(combinators));
-	else {
+	else if (newIndex === 0) {
+		if (rorg.path?.at(-1) === 0 && combinatorSucceeding) insertRuleOrGroup(newIndex, rorg, combinatorSucceeding);
+		else insertRuleOrGroup(newIndex, rorg, parentToInsertInto.rules[1] ?? combinatorPreceding ?? getFirstOption(combinators));
+	} else {
 		const normalizedNewIndex = newIndex % 2 === 0 ? newIndex - 1 : newIndex;
 		if (combinatorPreceding) insertRuleOrGroup(normalizedNewIndex, combinatorPreceding, rorg);
 		else insertRuleOrGroup(normalizedNewIndex, parentToInsertInto.rules[normalizedNewIndex - 2] ?? combinatorSucceeding ?? getFirstOption(combinators), rorg);
@@ -6214,7 +7064,7 @@ const insertInPlace = (query, ruleOrGroup, path, options = {}) => {
 *
 * @group Query Tools
 */
-const group = (query, sourcePathOrID, targetPathOrID, options = {}) => (0, immer.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.
@@ -6342,7 +7192,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?.({
 		qbId,
 		...payload
@@ -6379,7 +7229,8 @@ const createQueryActions = (config = {}) => {
 			const newQuery = add(query, newRule, parentPath, {
 				combinators,
 				combinatorPreceding: newRule.combinatorPreceding,
-				idGenerator
+				idGenerator,
+				freeze
 			});
 			log({
 				type: LogType.add,
@@ -6415,7 +7266,8 @@ const createQueryActions = (config = {}) => {
 			const newQuery = add(query, newGroup, parentPath, {
 				combinators,
 				combinatorPreceding: newGroup.combinatorPreceding ?? void 0,
-				idGenerator
+				idGenerator,
+				freeze
 			});
 			log({
 				type: LogType.add,
@@ -6443,7 +7295,8 @@ const createQueryActions = (config = {}) => {
 				getRuleDefaultOperator,
 				getValueSources,
 				getRuleDefaultValue,
-				getMatchModes
+				getMatchModes,
+				freeze
 			});
 			log({
 				type: LogType.update,
@@ -6476,7 +7329,7 @@ const createQueryActions = (config = {}) => {
 				});
 				return;
 			}
-			const newQuery = remove(query, path);
+			const newQuery = remove(query, path, { freeze });
 			log({
 				type: LogType.remove,
 				query,
@@ -6501,7 +7354,8 @@ const createQueryActions = (config = {}) => {
 			const nextQuery = move(query, oldPath, newPath, {
 				clone,
 				combinators,
-				idGenerator
+				idGenerator,
+				freeze
 			});
 			const isGroup = isRuleGroup(ruleOrGroup);
 			const callback = isGroup ? onMoveGroup : onMoveRule;
@@ -6547,7 +7401,8 @@ const createQueryActions = (config = {}) => {
 			const nextQuery = group(query, sourcePath, targetPath, {
 				clone,
 				combinators,
-				idGenerator
+				idGenerator,
+				freeze
 			});
 			const isGroup = isRuleGroup(ruleOrGroup);
 			const callback = isGroup ? onGroupGroup : onGroupRule;
@@ -6591,10 +7446,12 @@ const createQueryActions = (config = {}) => {
 */
 const createRule = ({ fields, getDefaultField, getRuleDefaultOperator, getValueSources, getMatchModes, getRuleDefaultValue, idGenerator = generateID }) => {
 	let field = getFirstOption(fields) ?? "";
-	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 = getFirstOption(getValueSources(field, operator, { fieldData })) ?? "value";
@@ -6641,92 +7498,8 @@ 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) => {
-	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) {
-		const props = changedProps(prev, next);
-		return props.length === 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) return ownProps.length === 0 ? "" : `${next.id ?? ""}:${ownProps.join(",")}`;
-	if (ownProps.length > 0) return structuralSignature;
-	return signatureOfNode(prev.rules[changedIndex], next.rules[changedIndex], next.id ?? "", 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/QueryManager.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.
-*
-* @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.
 *
@@ -6746,6 +7519,57 @@ var QueryManagerError = class QueryManagerError extends Error {
 	}
 };
 /**
+* 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 = (0, immer.freeze)({
+	query: true,
+	config: false
+});
+const configChange = (0, immer.freeze)({
+	query: false,
+	config: true
+});
+const queryAndConfigChange = (0, immer.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;
+};
+/**
 * Stateful wrapper around the {@link add}/{@link remove}/{@link update}/{@link move}/
 * {@link insert}/{@link group} query tools, plus rule/group factories, {@link defaultValidator
 * validation}, and {@link formatQuery formatting}.
@@ -6753,7 +7577,8 @@ var QueryManagerError = class QueryManagerError extends Error {
 * 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 });
@@ -6769,194 +7594,188 @@ var QueryManagerError = class QueryManagerError extends Error {
 * @group Query Tools
 */
 var QueryManager = class QueryManager {
-	#query;
-	#options;
-	#fields;
-	#fieldMap;
-	#operators;
-	#combinators;
-	#idGenerator;
-	#validator;
-	#strict;
-	#respectDisabled;
-	#onInvalidTarget;
-	#listeners = /* @__PURE__ */ new Set();
-	#historyEnabled;
-	#maxHistory;
-	#coalesceMs;
-	#now;
-	/** Incremented by every {@link QueryManager.reconfigure} call. See `getConfigVersion`. */
-	#configVersion = 0;
-	#past = [];
-	#future = [];
-	#lastSig;
-	#lastAt = 0;
-	#batchDepth = 0;
-	#batchSnapshot;
-	/** Whether a history-stack method ran inside the batch currently in progress. */
-	#historyBypassed = false;
 	/**
-	* The query the cached fields below were derived from. Caches are keyed on query _identity_
-	* rather than invalidated from {@link QueryManager.#commit} because `undo`, `redo`, and
-	* `batch`'s rollback all assign `#query` directly.
+	* 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.
 	*/
-	#cacheFor;
-	#idPathIndex;
-	#validation;
+	get state() {
+		return this[kState];
+	}
 	constructor(query, options = {}) {
-		this.#applyOptions(options);
-		this.#query = (0, immer.freeze)(query ? prepareRuleGroup(query, { idGenerator: this.#idGenerator }) : 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 ? (0, immer.freeze)(x, true) : x;
 	}
 	/**
-	* Assigns `#options` and every field derived from it. Shared by the constructor and
+	* 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) {
-		this.#options = options;
-		this.#idGenerator = options.idGenerator ?? generateID;
-		this.#validator = options.validator ?? defaultValidator;
-		this.#strict = options.strict ?? false;
-		this.#respectDisabled = options.respectDisabled ?? true;
-		this.#onInvalidTarget = options.onInvalidTarget;
+	applyOptions(options) {
+		this.state.options = options;
+		this.state.freezeEnabled = options.freeze ?? true;
+		this.state.idGenerator = options.idGenerator ?? generateID;
+		this.state.validator = options.validator ?? defaultValidator;
+		this.state.strict = options.strict ?? false;
+		this.state.respectDisabled = options.respectDisabled ?? true;
+		this.state.onInvalidTarget = options.onInvalidTarget;
 		const history = options.history ?? false;
 		const historyOptions = typeof history === "object" ? history : {};
-		this.#historyEnabled = history !== false;
-		this.#maxHistory = historyOptions.maxHistory ?? 50;
-		this.#coalesceMs = historyOptions.coalesceMs ?? 500;
-		this.#now = options.now ?? Date.now;
+		this.state.historyEnabled = history !== false;
+		this.state.maxHistory = historyOptions.maxHistory ?? 50;
+		this.state.coalesceMs = historyOptions.coalesceMs ?? 500;
+		this.state.now = options.now ?? Date.now;
 		const { optionList: fields, optionsMap: fieldMap } = prepareOptionList({
 			optionList: options.fields,
 			baseOption: options.baseField,
 			autoSelectOption: options.autoSelectField,
 			placeholder: options.translations?.fields
 		});
-		this.#fields = (0, immer.freeze)(fields, true);
-		this.#fieldMap = (0, immer.freeze)(fieldMap, true);
-		this.#operators = prepareOptionList({
+		this.state.fields = this.freeze(fields);
+		this.state.fieldMap = this.freeze(fieldMap);
+		this.state.operators = prepareOptionList({
 			optionList: options.operators ?? defaultOperators,
 			baseOption: options.baseOperator,
 			labelMap: defaultOperatorLabelMap,
 			autoSelectOption: options.autoSelectOperator,
 			placeholder: options.translations?.operators
 		}).optionList;
-		this.#combinators = (0, immer.freeze)(prepareOptionList({
+		this.state.combinators = this.freeze(prepareOptionList({
 			optionList: options.combinators ?? defaultCombinators,
 			baseOption: options.baseCombinator
-		}).optionList, true);
+		}).optionList);
 	}
 	/** Resolves the field configuration for a field name. */
-	#fieldData(field) {
-		return this.#fieldMap[field] ?? {};
+	fieldData(field) {
+		return this.state.fieldMap[field] ?? {};
 	}
 	/** Resolves the operator list for a field, mirroring `QueryBuilder`'s precedence. */
-	#operatorsFor(field) {
+	operatorsFor(field) {
 		return resolveOperatorList({
 			field,
-			fieldData: this.#fieldData(field),
-			getOperators: this.#options.getOperators,
-			operators: this.#operators,
-			baseOption: this.#options.baseOperator,
-			autoSelectOption: this.#options.autoSelectOperator,
-			placeholder: this.#options.translations?.operators
+			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.translations?.operators
 		});
 	}
 	/** Resolves the default operator for a field, mirroring `QueryBuilder`'s precedence. */
-	#defaultOperator(field) {
+	defaultOperator(field) {
 		return resolveDefaultOperator({
 			field,
-			fieldData: this.#fieldData(field),
-			getDefaultOperator: this.#options.getDefaultOperator,
-			getOperators: (f) => this.#operatorsFor(f)
+			fieldData: this.fieldData(field),
+			getDefaultOperator: this.state.options.getDefaultOperator,
+			getOperators: (f) => this.operatorsFor(f)
 		});
 	}
-	#valueSourcesFor(field, operator) {
-		return getValueSourcesUtil(this.#fieldData(field), operator, this.#options.getValueSources);
+	valueSourcesFor(field, operator) {
+		return getValueSourcesUtil(this.fieldData(field), operator, this.state.options.getValueSources);
 	}
-	#matchModesFor(field) {
-		return getMatchModesUtil(this.#fieldData(field), this.#options.getMatchModes);
+	matchModesFor(field) {
+		return getMatchModesUtil(this.fieldData(field), this.state.options.getMatchModes);
 	}
-	#valuesFor(field, operator) {
+	valuesFor(field, operator) {
 		return resolveValueList({
 			field,
 			operator,
-			fieldData: this.#fieldData(field),
-			getValues: this.#options.getValues,
-			autoSelectOption: this.#options.autoSelectValue,
-			placeholder: this.#options.translations?.values
+			fieldData: this.fieldData(field),
+			getValues: this.state.options.getValues,
+			autoSelectOption: this.state.options.autoSelectValue,
+			placeholder: this.state.options.translations?.values
 		});
 	}
-	#valueEditorTypeFor(field, operator) {
+	valueEditorTypeFor(field, operator) {
 		return resolveValueEditorType({
 			field,
 			operator,
-			fieldData: this.#fieldData(field),
-			getValueEditorType: this.#options.getValueEditorType
+			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.#options;
+	defaultValue(rule) {
+		const { getDefaultValue, getParameters, listsAsArrays } = this.state.options;
 		return getRuleDefaultValue(rule, {
-			fieldData: this.#fieldData(rule.field),
-			fields: this.#fields,
+			fieldData: this.fieldData(rule.field),
+			fields: this.state.fields,
 			listsAsArrays,
-			getValueEditorType: (f, o) => this.#valueEditorTypeFor(f, o),
-			getValues: (f, o) => this.#valuesFor(f, o),
+			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))
+			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 {@link QueryManager.#defaultValue} and
-	* {@link QueryManager.getRuleContext} so both see the same shape.
+	* other option list. Shared by `defaultValue` and {@link QueryManager.getRuleContext} so both
+	* see the same shape.
 	*/
-	#parametersFor(field, operator, misc) {
+	parametersFor(field, operator, misc) {
 		return prepareOptionList({
-			optionList: this.#options.getParameters?.(field, operator, misc) ?? [],
-			autoSelectOption: this.#options.autoSelectValue
+			optionList: this.state.options.getParameters?.(field, operator, misc) ?? [],
+			autoSelectOption: this.state.options.autoSelectValue
 		}).optionList;
 	}
 	/** Defaults shared by every mutating method, overridable per call. */
-	#guardOptions() {
-		const { maxLevels } = this.#options;
+	guardOptions() {
+		const { maxLevels } = this.state.options;
 		return {
+			freeze: this.state.freezeEnabled,
 			maxLevels: (maxLevels ?? 0) > 0 ? Number(maxLevels) : Infinity,
-			respectDisabled: this.#respectDisabled,
-			disabledPaths: this.#options.disabledPaths,
-			queryDisabled: this.#options.queryDisabled
+			respectDisabled: this.state.respectDisabled,
+			disabledPaths: this.state.options.disabledPaths,
+			queryDisabled: this.state.options.queryDisabled
 		};
 	}
-	#toolOptions() {
+	toolOptions() {
 		return {
-			combinators: this.#combinators,
-			idGenerator: this.#idGenerator,
-			...this.#guardOptions()
+			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 ?? this.#strict;
-		const handler = onInvalidTarget ?? this.#onInvalidTarget;
+	onAbort({ strict, onInvalidTarget }) {
+		const strictMain = strict ?? this.state.strict;
+		const handler = onInvalidTarget ?? this.state.onInvalidTarget;
 		return (info) => {
 			handler?.(info);
 			if (strictMain && strictAbortReasonSet.has(info.reason)) throw new QueryManagerError(info);
 		};
 	}
 	/** Defaults for {@link update}, so resets mirror `QueryBuilder`'s behavior. */
-	#updateOptions() {
+	updateOptions() {
 		return {
-			getRuleDefaultOperator: (f) => this.#defaultOperator(f),
-			getRuleDefaultValue: (r) => this.#defaultValue(r),
-			getValueSources: (f, o) => this.#valueSourcesFor(f, o),
-			getMatchModes: (f) => this.#matchModesFor(f),
-			resetOnFieldChange: this.#options.resetOnFieldChange,
-			resetOnOperatorChange: this.#options.resetOnOperatorChange,
-			...this.#guardOptions()
+			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()
 		};
 	}
 	/**
@@ -6964,52 +7783,52 @@ var QueryManager = class QueryManager {
 	* 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.#query;
+	commit(next) {
+		const prev = this.state.query;
 		if (prev === next) return;
-		this.#query = next;
-		if (this.#batchDepth > 0) return;
-		this.#record(prev, next);
-		this.#notify();
+		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.#historyEnabled) return;
+	record(prev, next) {
+		if (!this.state.historyEnabled) return;
 		const sig = signatureOf(prev, next);
 		if (sig === "") return;
-		const now = this.#now();
-		if (!(sig !== "~structural" && sig === this.#lastSig && now - this.#lastAt < this.#coalesceMs)) {
-			this.#past.push(prev);
-			if (this.#past.length > this.#maxHistory) this.#past.shift();
-			this.#future = [];
+		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.#lastSig = sig;
-		this.#lastAt = now;
+		this.state.lastSig = sig;
+		this.state.lastAt = now;
 	}
-	#notify() {
-		for (const listener of this.#listeners) listener();
+	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
+	* `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.#batchDepth > 0) this.#historyBypassed = true;
+	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.#cacheFor === this.#query) return;
-		this.#cacheFor = this.#query;
-		this.#idPathIndex = void 0;
-		this.#validation = void 0;
+	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
@@ -7017,7 +7836,7 @@ var QueryManager = class QueryManager {
 	*
 	* @yields The subtree rooted at `node`, depth-first in pre-order, starting with `node` itself.
 	*/
-	*#walkFrom(node, path, parent) {
+	*walkFrom(node, path, parent) {
 		yield {
 			node,
 			path,
@@ -7027,34 +7846,35 @@ var QueryManager = class QueryManager {
 		const startGroup = node;
 		for (const [index, child] of startGroup.rules.entries()) {
 			if (typeof child === "string") continue;
-			yield* this.#walkFrom(child, [...path, index], startGroup);
+			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.#idPathIndex) {
+	index() {
+		this.ensureCache();
+		if (!this.state.idPathIndex) {
 			const index = /* @__PURE__ */ new Map();
-			for (const { node, path } of this.#walkFrom(this.#query, [], null)) if (node.id !== void 0 && !index.has(node.id)) index.set(node.id, path);
-			this.#idPathIndex = index;
+			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.#idPathIndex;
+		return this.state.idPathIndex;
 	}
 	/** Resolves a path or `id` to a path, or `null` when the `id` isn't present. */
-	#toPath(pathOrID) {
-		return typeof pathOrID === "string" ? this.#index().get(pathOrID) ?? null : pathOrID;
+	toPath(pathOrID) {
+		return typeof pathOrID === "string" ? this.index().get(pathOrID) ?? null : pathOrID;
 	}
 	/**
-	* 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 = () => this.#query;
+	getQuery = () => this.state.query;
 	/** Replaces the current query, ensuring every rule and group has an `id`. */
 	setQuery(query) {
-		this.#commit((0, immer.freeze)(prepareRuleGroup(query, { idGenerator: this.#idGenerator }), true));
+		this.commit(this.freeze(prepareRuleGroup(query, { idGenerator: this.state.idGenerator })));
 		return this;
 	}
 	/**
@@ -7063,13 +7883,13 @@ var QueryManager = class QueryManager {
 	*/
 	createRule() {
 		return createRule({
-			fields: this.#fields,
-			getDefaultField: this.#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.#idGenerator
+			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
 		});
 	}
 	/**
@@ -7078,10 +7898,10 @@ var QueryManager = class QueryManager {
 	*/
 	createRuleGroup(independentCombinators) {
 		return createRuleGroup({
-			combinators: this.#combinators,
-			addRuleToNewGroups: this.#options.addRuleToNewGroups,
+			combinators: this.state.combinators,
+			addRuleToNewGroups: this.state.options.addRuleToNewGroups,
 			createRule: () => this.createRule(),
-			idGenerator: this.#idGenerator
+			idGenerator: this.state.idGenerator
 		}, independentCombinators);
 	}
 	/**
@@ -7090,10 +7910,10 @@ var QueryManager = class QueryManager {
 	*/
 	add(ruleOrGroup, parentPathOrID = [], options = {}) {
 		const { strict, onInvalidTarget, ...toolOptions } = options;
-		this.#commit(add(this.#query, ruleOrGroup, parentPathOrID, {
-			...this.#toolOptions(),
+		this.commit(add(this.state.query, ruleOrGroup, parentPathOrID, {
+			...this.toolOptions(),
 			...toolOptions,
-			onAbort: this.#onAbort({
+			onAbort: this.onAbort({
 				strict,
 				onInvalidTarget
 			})
@@ -7103,10 +7923,10 @@ 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, ...toolOptions } = options;
-		this.#commit(remove(this.#query, pathOrID, {
-			...this.#guardOptions(),
+		this.commit(remove(this.state.query, pathOrID, {
+			...this.guardOptions(),
 			...toolOptions,
-			onAbort: this.#onAbort({
+			onAbort: this.onAbort({
 				strict,
 				onInvalidTarget
 			})
@@ -7123,23 +7943,23 @@ var QueryManager = class QueryManager {
 		];
 		const { strict, onInvalidTarget, ...toolOptions } = args[optionsIndex] ?? {};
 		args[optionsIndex] = {
-			...this.#updateOptions(),
+			...this.updateOptions(),
 			...toolOptions,
-			onAbort: this.#onAbort({
+			onAbort: this.onAbort({
 				strict,
 				onInvalidTarget
 			})
 		};
-		this.#commit(update(this.#query, ...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, ...toolOptions } = options;
-		this.#commit(move(this.#query, oldPathOrID, newPath, {
-			...this.#toolOptions(),
+		this.commit(move(this.state.query, oldPathOrID, newPath, {
+			...this.toolOptions(),
 			...toolOptions,
-			onAbort: this.#onAbort({
+			onAbort: this.onAbort({
 				strict,
 				onInvalidTarget
 			})
@@ -7152,10 +7972,10 @@ var QueryManager = class QueryManager {
 	*/
 	insert(ruleOrGroup, path, options = {}) {
 		const { strict, onInvalidTarget, ...toolOptions } = options;
-		this.#commit(insert(this.#query, ruleOrGroup, path, {
-			...this.#toolOptions(),
+		this.commit(insert(this.state.query, ruleOrGroup, path, {
+			...this.toolOptions(),
 			...toolOptions,
-			onAbort: this.#onAbort({
+			onAbort: this.onAbort({
 				strict,
 				onInvalidTarget
 			})
@@ -7168,10 +7988,10 @@ var QueryManager = class QueryManager {
 	*/
 	group(sourcePathOrID, targetPathOrID, options = {}) {
 		const { strict, onInvalidTarget, ...toolOptions } = options;
-		this.#commit(group(this.#query, sourcePathOrID, targetPathOrID, {
-			...this.#toolOptions(),
+		this.commit(group(this.state.query, sourcePathOrID, targetPathOrID, {
+			...this.toolOptions(),
 			...toolOptions,
-			onAbort: this.#onAbort({
+			onAbort: this.onAbort({
 				strict,
 				onInvalidTarget
 			})
@@ -7184,7 +8004,7 @@ var QueryManager = class QueryManager {
 	* defaults filled in for options that were never provided.
 	*/
 	getOptions() {
-		return (0, immer.freeze)({ ...this.#options });
+		return (0, immer.freeze)({ ...this.state.options });
 	}
 	/**
 	* Updates the manager's configuration in place, keeping the current query, the undo/redo
@@ -7207,24 +8027,37 @@ 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) {
-		this.#applyOptions((0, immer.freeze)(config?.replace ? { ...options } : {
-			...this.#options,
+		const merged = config?.replace ? { ...options } : {
+			...this.state.options,
 			...options
-		}));
-		this.#validation = void 0;
-		this.#reconcileHistoryConfig();
-		++this.#configVersion;
-		this.#notify();
+		};
+		if (optionsEqual(this.state.options, merged)) return this;
+		this.applyOptions((0, immer.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
+	* {@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.
 	*
@@ -7232,13 +8065,13 @@ var QueryManager = class QueryManager {
 	* {@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.#historyEnabled) {
-			if (this.#past.length > this.#maxHistory) this.#past.splice(0, this.#past.length - this.#maxHistory);
+	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.#past = [];
-			this.#future = [];
-			this.#lastSig = void 0;
+			this.state.past = [];
+			this.state.future = [];
+			this.state.lastSig = void 0;
 		}
 	}
 	/**
@@ -7250,7 +8083,7 @@ var QueryManager = class QueryManager {
 	* {@link QueryManager.subscribe}. The `useQueryManager` hook from `react-querybuilder`
 	* already does this.
 	*/
-	getConfigVersion = () => this.#configVersion;
+	getConfigVersion = () => this.state.configVersion;
 	/**
 	* Creates an independent manager with the same configuration and the current query.
 	*
@@ -7262,8 +8095,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?.regenerateIDs ? regenerateIDs(this.#query, { idGenerator: this.#idGenerator }) : this.#query;
-		return new QueryManager(query, this.#options);
+		const query = options?.regenerateIDs ? regenerateIDs(this.state.query, { idGenerator: this.state.idGenerator }) : this.state.query;
+		return new QueryManager(query, this.state.options);
 	}
 	/**
 	* Registers a listener called after every change to the query, and returns a function that
@@ -7279,11 +8112,15 @@ 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) => {
-		this.#listeners.add(listener);
+		this.state.listeners.add(listener);
 		return () => {
-			this.#listeners.delete(listener);
+			this.state.listeners.delete(listener);
 		};
 	};
 	/**
@@ -7301,75 +8138,78 @@ var QueryManager = class QueryManager {
 	* its own, leaving the stacks exactly as those methods left them.
 	*/
 	batch(fn) {
-		this.#batchDepth++;
-		if (this.#batchDepth === 1) this.#batchSnapshot = {
-			query: this.#query,
-			past: [...this.#past],
-			future: [...this.#future],
-			lastSig: this.#lastSig,
-			lastAt: this.#lastAt
+		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 (this.#batchDepth === 1) {
-				const snapshot = this.#batchSnapshot;
-				this.#query = snapshot.query;
-				this.#past = snapshot.past;
-				this.#future = snapshot.future;
-				this.#lastSig = snapshot.lastSig;
-				this.#lastAt = snapshot.lastAt;
-				this.#reconcileHistoryConfig();
+			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 {
-			this.#batchDepth--;
-			if (this.#batchDepth === 0) {
-				const { query: base } = this.#batchSnapshot;
-				this.#batchSnapshot = void 0;
-				if (base !== this.#query) {
-					if (!this.#historyBypassed) this.#record(base, this.#query);
-					this.#notify();
+			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);
 				}
-				this.#historyBypassed = 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 this.#past.length > 0;
+		return this.state.past.length > 0;
 	}
 	/** Whether there is an undone query to restore. Always `false` unless `history` is enabled. */
 	canRedo() {
-		return this.#future.length > 0;
+		return this.state.future.length > 0;
 	}
 	/** Restores the previous query. No-op when {@link QueryManager.canUndo} is `false`. */
 	undo() {
-		if (this.#past.length === 0) return this;
-		this.#future.unshift(this.#query);
-		this.#query = this.#past.pop();
-		this.#lastSig = void 0;
-		this.#markHistoryBypassed();
-		if (this.#batchDepth === 0) this.#notify();
+		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 (this.#future.length === 0) return this;
-		this.#past.push(this.#query);
-		this.#query = this.#future.shift();
-		this.#lastSig = void 0;
-		this.#markHistoryBypassed();
-		if (this.#batchDepth === 0) this.#notify();
+		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() {
-		this.#markHistoryBypassed();
-		this.#past = [];
-		this.#future = [];
-		this.#lastSig = void 0;
+		this.markHistoryBypassed();
+		this.state.past = [];
+		this.state.future = [];
+		this.state.lastSig = void 0;
 		return this;
 	}
 	/**
@@ -7378,8 +8218,8 @@ var QueryManager = class QueryManager {
 	*/
 	getHistory() {
 		return {
-			past: [...this.#past],
-			future: [...this.#future]
+			past: [...this.state.past],
+			future: [...this.state.future]
 		};
 	}
 	/**
@@ -7389,12 +8229,12 @@ var QueryManager = class QueryManager {
 	* one that depends on anything other than the query) may run fewer times than expected.
 	*/
 	validate() {
-		this.#ensureCache();
-		this.#validation ??= this.#validator(this.#query);
-		return this.#validation;
+		this.ensureCache();
+		this.state.validation ??= this.state.validator(this.state.query);
+		return this.state.validation;
 	}
 	format(options) {
-		return formatQuery(this.#query, options);
+		return formatQuery(this.state.query, options);
 	}
 	/**
 	* Yields every rule and group in the query, depth-first in pre-order, starting with the root
@@ -7414,18 +8254,18 @@ var QueryManager = class QueryManager {
 	*/
 	*walk(options = {}) {
 		const { from, rulesOnly, groupsOnly } = options;
-		let start = this.#query;
+		let start = this.state.query;
 		let startPath = [];
 		let startParent = null;
 		if (from !== void 0) {
-			const path = this.#toPath(from);
-			const node = path && findPath(path, this.#query);
+			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), this.#query);
+			startParent = path.length === 0 ? null : findPath(getParentPath(path), this.state.query);
 		}
-		for (const entry of this.#walkFrom(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;
@@ -7470,34 +8310,34 @@ var QueryManager = class QueryManager {
 	* index, unresolvable paths are always normalized to `null` here.
 	*/
 	findPath(path) {
-		return findPath(path, this.#query) ?? null;
+		return findPath(path, this.state.query) ?? 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 = this.#index().get(id);
-		return path === void 0 ? null : findPath(path, this.#query);
+		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
 	* none. Backed by an index built once per query, so repeated lookups are constant time.
 	*/
 	getPathOfID(id) {
-		return this.#index().get(id) ?? null;
+		return this.index().get(id) ?? 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, this.#query);
+		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) {
-		const path = this.#toPath(pathOrID);
-		return path === null ? null : findPath(path, this.#query) ?? null;
+		const path = this.toPath(pathOrID);
+		return path === null ? null : findPath(path, this.state.query) ?? null;
 	}
 	/**
 	* Returns the rule at the given path or `id`, or `null` if it can't be resolved _or_ resolves
@@ -7520,24 +8360,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 = this.#toPath(pathOrID);
+		const path = this.toPath(pathOrID);
 		if (path === null || path.length === 0) return null;
-		if (!findPath(path, this.#query)) return null;
-		return findPath(getParentPath(path), this.#query);
+		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 this.#fields;
+		return this.state.fields;
 	}
 	/**
 	* The normalized combinator list, as the `QueryBuilder` component would render it. Needed to
 	* populate a combinator selector.
 	*/
 	getCombinators() {
-		return this.#combinators;
+		return this.state.combinators;
 	}
 	/**
 	* The field configuration for a field name. When the field isn't configured, returns the same
@@ -7545,27 +8385,51 @@ var QueryManager = class QueryManager {
 	* {@link QueryManager.getRuleContext} reports as `fieldData`, so both access paths agree.
 	*/
 	getFieldData(field) {
-		return getFieldData(field, this.#fieldMap);
+		return getFieldData(field, this.state.fieldMap);
 	}
 	/** The operator list for a field, mirroring `QueryBuilder`'s precedence. */
 	getOperators(field) {
-		return this.#operatorsFor(field);
+		return this.operatorsFor(field);
 	}
 	/** The value sources available for a field/operator pair. */
 	getValueSources(field, operator) {
-		return this.#valueSourcesFor(field, operator);
+		return this.valueSourcesFor(field, operator);
 	}
 	/** The match modes available for a field. */
 	getMatchModes(field) {
-		return this.#matchModesFor(field);
+		return this.matchModesFor(field);
 	}
 	/** The value option list for a field/operator pair. */
 	getValues(field, operator) {
-		return this.#valuesFor(field, operator);
+		return this.valuesFor(field, operator);
 	}
 	/** The value editor type for a field/operator pair. */
 	getValueEditorType(field, operator) {
-		return this.#valueEditorTypeFor(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,
@@ -7580,16 +8444,16 @@ var QueryManager = class QueryManager {
 		if (!rule) return null;
 		const validation = this.validate();
 		return deriveRuleContext(rule, {
-			fields: this.#fields,
-			fieldMap: this.#fieldMap,
-			getInputType: (f, o, misc) => this.#options.getInputType?.(f, o, misc) ?? null,
-			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),
+			fields: this.state.fields,
+			fieldMap: this.state.fieldMap,
+			getInputType: (f, o, misc) => this.state.options.getInputType?.(f, o, misc) ?? null,
+			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) => this.#options.getSubQueryBuilderProps?.(f, misc) ?? {}
+			getSubQueryBuilderProps: (f, misc) => this.state.options.getSubQueryBuilderProps?.(f, misc) ?? {}
 		}, {
 			validationMap: typeof validation === "boolean" ? {} : validation,
 			id: rule.id
@@ -7605,32 +8469,32 @@ var QueryManager = class QueryManager {
 		const ruleGroup = this.getGroup(pathOrID);
 		if (!ruleGroup) return null;
 		const validation = this.validate();
-		return deriveRuleGroupContext(ruleGroup, this.#combinators, {
+		return deriveRuleGroupContext(ruleGroup, this.state.combinators, {
 			validationMap: typeof validation === "boolean" ? {} : validation,
 			id: ruleGroup.id
 		});
 	}
 	/** Whether the current query uses independent combinators. */
 	isIC() {
-		return isRuleGroupTypeIC(this.#query);
+		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(this.#query, other);
+		return signatureOf(this.state.query, other);
 	}
 	/** Generates a {@link DiagnosticsResult}. Shorthand for `format('diagnostics')`. */
 	diagnostics() {
-		return formatQuery(this.#query, "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 this.#query;
+		return this.state.query;
 	}
 	/**
 	* Returns a new manager with the same configuration and the current query converted to use
@@ -7638,7 +8502,7 @@ var QueryManager = class QueryManager {
 	* {@link QueryManager.clone}, subscribers and history are not carried over.
 	*/
 	toIC() {
-		return new QueryManager(convertToIC(this.#query), this.#options);
+		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
@@ -7646,7 +8510,7 @@ var QueryManager = class QueryManager {
 	* {@link QueryManager.clone}, subscribers and history are not carried over.
 	*/
 	fromIC() {
-		return new QueryManager(convertFromIC(this.#query), this.#options);
+		return new QueryManager(convertFromIC(this.state.query), this.state.options);
 	}
 	/**
 	* Runs {@link transformQuery} against the current query and returns its result.
@@ -7656,7 +8520,7 @@ var QueryManager = class QueryManager {
 	* shapes that are no longer valid queries. This manager is never modified.
 	*/
 	transform(options) {
-		return transformQuery(this.#query, options);
+		return transformQuery(this.state.query, options);
 	}
 };
 //#endregion
@@ -7673,6 +8537,9 @@ exports.celCombinatorMap = celCombinatorMap;
 exports.clsx = clsx;
 exports.coerceBigIntValue = coerceBigIntValue;
 exports.coerceInputType = coerceInputType;
+exports.controlKeys = controlKeys;
+exports.controlKind = controlKind;
+exports.controlPropKeys = controlPropKeys;
 exports.convertFromIC = convertFromIC;
 exports.convertQuery = convertQuery;
 exports.convertToIC = convertToIC;
@@ -7848,6 +8715,7 @@ exports.numericRegex = numericRegex;
 exports.numerifyValues = numerifyValues;
 exports.objectEntries = objectEntries;
 exports.objectKeys = objectKeys;
+exports.optionsEqual = optionsEqual;
 exports.parseNumber = parseNumber;
 exports.pathIsDisabled = pathIsDisabled;
 exports.pathIsDisabledByPaths = pathIsDisabledByPaths;
@@ -7874,6 +8742,8 @@ exports.resolveOperatorList = resolveOperatorList;
 exports.resolveValueEditorType = resolveValueEditorType;
 exports.resolveValueList = resolveValueList;
 exports.rootPath = rootPath;
+exports.setAutoFreeze = setAutoFreeze;
+exports.shouldCoalesce = shouldCoalesce;
 exports.shouldRenderAsNumber = shouldRenderAsNumber;
 exports.signatureOf = signatureOf;
 exports.sparqlVar = sparqlVar;
@@ -7900,6 +8770,7 @@ exports.uniqOptList = uniqOptList;
 exports.update = update;
 exports.updateInPlace = updateInPlace;
 exports.uuidV4regex = uuidV4regex;
+exports.valuesEqual = valuesEqual;
 exports.withParamPrefix = withParamPrefix;
 exports.wrapLikeFragment = wrapLikeFragment;