@limetech/lime-crm-building-blocks 2.3.1 → 2.4.1

package/dist/types/components.d.ts

@@ -6,9 +6,9 @@
  */
 import { HTMLStencilElement, JSXBase } from "./stencil-public-runtime";
 import { AlertType } from "./components/alert-dialog/alert-dialog.types";
-import { AggregateOperator, ComponentDescriptor, ContextMap, ContextScope, Expression, JsonValue, LimeFileUrlType, LimeType, LimeWebComponentContext, LimeWebComponentPlatform, NotExpression, Operator, PrimitiveMetadata, PropertyType, Rule, RuleRef } from "@limetech/lime-web-components";
+import { AggregateOperator, ComponentDescriptor, ContextMap, ContextScope, Expression, LimeFileUrlType, LimeType, LimeWebComponentContext, LimeWebComponentPlatform, NotExpression, Operator, PropertyType, Rule } from "@limetech/lime-web-components";
 import { BrowserItem } from "./components/browser/browser-item.types";
-import { ActionBarItem, CustomElementDefinition, DateType, EditorUiType, FileInfo, FormInfo, Icon, IconName, Image, Languages, ListItem, ListSeparator, MenuItem, OpenDirection } from "@limetech/lime-elements";
+import { ActionBarItem, CustomElementDefinition, DateType, EditorUiType, FileInfo, FormInfo, Icon, IconName, Image, Languages, ListItem, ListSeparator, MenuItem, MenuSearcher, OpenDirection } from "@limetech/lime-elements";
 import { ChatIconList } from "./components/chat-list/chat-icon-list/chat-icon-list.types";
 import { ChatItem } from "./components/chat-list/chat-item/chat-item.types";
 import { ChatListItem } from "./components/chat-list/chat-list.types";
@@ -38,9 +38,9 @@ import { RuleEditorMode } from "./components/rule-editor/rule-editor.types";
 import { TriggerMap } from "./components/text-editor/text-editor.types";
 import { ValueComparisonEditorValue } from "./components/rule-editor/value-comparison-editor/value-comparison-editor";
 export { AlertType } from "./components/alert-dialog/alert-dialog.types";
-export { AggregateOperator, ComponentDescriptor, ContextMap, ContextScope, Expression, JsonValue, LimeFileUrlType, LimeType, LimeWebComponentContext, LimeWebComponentPlatform, NotExpression, Operator, PrimitiveMetadata, PropertyType, Rule, RuleRef } from "@limetech/lime-web-components";
+export { AggregateOperator, ComponentDescriptor, ContextMap, ContextScope, Expression, LimeFileUrlType, LimeType, LimeWebComponentContext, LimeWebComponentPlatform, NotExpression, Operator, PropertyType, Rule } from "@limetech/lime-web-components";
 export { BrowserItem } from "./components/browser/browser-item.types";
-export { ActionBarItem, CustomElementDefinition, DateType, EditorUiType, FileInfo, FormInfo, Icon, IconName, Image, Languages, ListItem, ListSeparator, MenuItem, OpenDirection } from "@limetech/lime-elements";
+export { ActionBarItem, CustomElementDefinition, DateType, EditorUiType, FileInfo, FormInfo, Icon, IconName, Image, Languages, ListItem, ListSeparator, MenuItem, MenuSearcher, OpenDirection } from "@limetech/lime-elements";
 export { ChatIconList } from "./components/chat-list/chat-icon-list/chat-icon-list.types";
 export { ChatItem } from "./components/chat-list/chat-item/chat-item.types";
 export { ChatListItem } from "./components/chat-list/chat-list.types";
@@ -537,6 +537,10 @@ export namespace Components {
           * The kinds of condition a user can add, offered as a menu when the add button is pressed. The chosen item is passed to `adapter.createLeaf`.  Leave it unset when every condition in the tree is of the same kind: a blank one can simply be inserted, and its editor settles the rest, so pressing the button is the whole interaction. Set it when conditions come in kinds that have nothing in common — "the deal is worth more than 100 000", "the user belongs to a group", "it is the first day of the month" — where nothing can be inserted until the user says which.  The menu has to be rendered here rather than by the consumer, because the button it hangs from lives inside this component.
          */
         "addOptions"?: Array<MenuItem | ListSeparator>;
+        /**
+          * How to narrow `addOptions` as the user types, which is what puts a search field at the top of the add menu.  Worth setting as soon as the kinds on offer stop fitting on a screen — and a consumer whose kinds are contributed by add-ons cannot know that they still do. `addOptions` is still what the menu opens on, so an unsearched menu reads exactly as it did before.
+         */
+        "addSearcher"?: MenuSearcher;
         /**
           * Which combinators to offer in the group dropdowns, in the order given.  All four are offered by default. "Not all of the following" and "None of the following" are harder to reason about than the two they negate, so a consumer whose users would be better served without them passes `['all', 'any']`. A group that already uses a combinator left off this list still shows it, rather than misrepresenting itself as using one of the offered ones.
           * @default [         ...CONDITION_TREE_COMBINATORS,     ]
@@ -591,6 +595,10 @@ export namespace Components {
           * Title of the condition, shown above the editor when there is a header to show at all.
          */
         "heading"?: string;
+        /**
+          * The condition's glyph, shown beside the heading. The same one the chip carries, so that the popover reads as the chip opened up rather than as somewhere else.
+         */
+        "icon"?: IconName;
         /**
           * Whether the condition is negated. `undefined` means the condition expresses its own polarity and no switch is offered.
          */
@@ -2527,47 +2535,116 @@ export namespace Components {
         "value": RuleArgFilterEditorValue;
     }
     /**
-     * Popover content for a rule-editor chip. Carries its own styles so
-     * they travel with the element when `limel-popover` portals it out of
-     * the rule-editor's shadow DOM.
+     * A rule condition as a chip, in place of the `limebb-filter-chip` the tree
+     * draws by default.
+     * A filter condition is a sentence and that chip lays it out as one, with the
+     * property captioned above the value. A rule condition is a name with no value
+     * under it, so the name is the whole chip. Implements `ConditionChip`.
      * @private 
      */
-    interface LimebbRuleChipPopover {
+    interface LimebbRuleConditionChip {
         /**
-          * Bridges the rule editor's context across the `limel-popover` portal.
+          * @inheritdoc 
+          * @default false
          */
-        "context": LimeWebComponentContext;
+        "disabled": boolean;
         /**
+          * The condition's glyph.
+         */
+        "icon"?: IconName;
+        /**
+          * The glyph's colour, which travels beside the name because `ConditionTreeChip.icon` has no room for it.
+         */
+        "iconColor"?: string;
+        /**
+          * @inheritdoc 
           * @default false
          */
-        "disabled": boolean;
+        "invalid": boolean;
+        /**
+          * The name of the condition.
+         */
+        "label": string;
         /**
-          * Forwarded to the embedded config component so it can pull focus when this popover opens. The rule editor sets it only when the chip was just added via the picker, so clicking an existing chip does not steal focus. The component decides when it is ready to receive focus (e.g. after loading its own data).
+          * Whether the condition is negated. The chip has to say so: the switch that sets it is out of sight inside the editor.
           * @default false
          */
-        "focusOnOpen": boolean;
+        "negated": boolean;
+        /**
+          * Platform service provider. Unread, but declared so that the tree setting it does not leave it in the DOM as an attribute.
+         */
+        "platform": LimeWebComponentPlatform;
         /**
+          * Deliberately not passed on to `limel-chip`, which would render it as a disabled button. A condition's arguments live behind this chip and nowhere else, so a chip that cannot be opened is a rule that cannot be read. It takes the delete control away instead — see `removable`.
+          * @inheritdoc 
+          * @default false
+         */
+        "readonly": boolean;
+        /**
+          * Whether the chip offers a control that deletes the condition. `readonly` overrules it here rather than in the caller, since withholding `readonly` from `limel-chip` also withholds the lock it puts on the cross.
           * @default true
          */
-        "isMutable": boolean;
+        "removable": boolean;
         /**
+          * Whether this condition's editor is the one currently open.
           * @default false
          */
-        "isNegated": boolean;
-        "metadata"?: PrimitiveMetadata;
+        "selected": boolean;
+    }
+    /**
+     * The editor `limebb-condition-tree` opens for one rule condition: whatever
+     * component the primitive named as its `configComponent`.
+     * The two sides speak about different things. The tree passes a whole condition
+     * and listens for `conditionChange`; a config component edits the reference's
+     * `args` and reports a plain `change`. Config components are registered by
+     * add-ons this repo does not own, so this side is the one that translates.
+     * @alpha 
+     * @private 
+     */
+    interface LimebbRuleConditionEditor {
+        /**
+          * The component the primitive declared for editing its args.
+         */
+        "configComponent": ComponentDescriptor;
+        /**
+          * Component context
+         */
+        "context": LimeWebComponentContext;
+        /**
+          * @inheritdoc 
+          * @default false
+         */
+        "disabled": boolean;
+        /**
+          * Forwarded so that component can take focus as it appears. Set only for a condition the author has just added.
+          * @default false
+         */
+        "focusOnOpen": boolean;
+        /**
+          * Platform service provider
+         */
         "platform": LimeWebComponentPlatform;
         /**
+          * @inheritdoc 
           * @default false
          */
         "readonly": boolean;
-        "refNode": RuleRef;
+        /**
+          * The condition being edited: a reference to a primitive, or the `not` around one.
+         */
+        "value": Rule;
     }
     /**
      * Tree editor for {@link Rule}.
-     * Renders a `Rule` value as a tree of nodes. Lets an author pick
-     * primitive refs in `all` / `any` groups, toggle negation, delete
-     * nodes, and edit per-primitive args via the editor declared on each
-     * primitive's metadata.
+     * Renders a `Rule` value as a `limebb-condition-tree`. Lets an author
+     * add primitive refs to `all` / `any` groups and to the negations of
+     * those two, nest groups, negate a single ref, delete nodes, and edit
+     * per-primitive args via the editor declared on each primitive's
+     * metadata.
+     * The tree owns every structural edit, and knows nothing about rules. A
+     * `Rule` reaches it through an adapter — see `condition-tree-adapter.ts`
+     * — which is also where the group negation the rule model writes as a
+     * `not` wrapper is folded into the combinator the tree shows.
      * The component is value-in / value-out. Pass `value` and listen for
      * `change`; persistence is the caller's concern.
      * Pass `availableContexts` to forward the list of context keys the
@@ -2609,7 +2686,7 @@ export namespace Components {
          */
         "context": LimeWebComponentContext;
         /**
-          * Whether or not the current property is disabled The mutation UI is hidden when set. The args editor is rendered with `disabled` forwarded to it.
+          * Whether or not the current property is disabled Every control stays where it is, dimmed and inert, when set. The args editor is rendered with `disabled` forwarded to it.
           * @inheritdoc
          */
         "disabled": boolean;
@@ -2640,7 +2717,7 @@ export namespace Components {
          */
         "platform": LimeWebComponentPlatform;
         /**
-          * Whether or not the current property is readonly The mutation UI (delete and negate toggles, add-group button) is hidden when set. The args editor for each ref is still rendered, with `readonly` forwarded to it.
+          * Whether or not the current property is readonly The controls that add, delete and negate are not rendered when set, leaving the rule to be read. The args editor for each ref is still rendered, with `readonly` forwarded to it.
           * @inheritdoc
          */
         "readonly": boolean;
@@ -2650,7 +2727,7 @@ export namespace Components {
          */
         "required": boolean;
         /**
-          * The value of the current property
+          * The value of the current property The rule under edit. Hand back what `change` emitted, not a copy: which condition is open, which have been visited and what validation said about each are all tracked by object identity, so a deep-cloned rule reads as a different one that happens to look the same.
           * @inheritdoc
          */
         "value": Rule | undefined;
@@ -3206,9 +3283,13 @@ export interface LimebbRuleArgFilterEditorCustomEvent<T> extends CustomEvent<T>
     detail: T;
     target: HTMLLimebbRuleArgFilterEditorElement;
 }
-export interface LimebbRuleChipPopoverCustomEvent<T> extends CustomEvent<T> {
+export interface LimebbRuleConditionChipCustomEvent<T> extends CustomEvent<T> {
     detail: T;
-    target: HTMLLimebbRuleChipPopoverElement;
+    target: HTMLLimebbRuleConditionChipElement;
+}
+export interface LimebbRuleConditionEditorCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLLimebbRuleConditionEditorElement;
 }
 export interface LimebbRuleEditorCustomEvent<T> extends CustomEvent<T> {
     detail: T;
@@ -4914,40 +4995,72 @@ declare global {
         prototype: HTMLLimebbRuleArgFilterEditorElement;
         new (): HTMLLimebbRuleArgFilterEditorElement;
     };
-    interface HTMLLimebbRuleChipPopoverElementEventMap {
-        "negate": boolean;
-        "updateArgs": JsonValue;
-        "deleteChip": void;
+    interface HTMLLimebbRuleConditionChipElementEventMap {
+        "remove": void;
+    }
+    /**
+     * A rule condition as a chip, in place of the `limebb-filter-chip` the tree
+     * draws by default.
+     * A filter condition is a sentence and that chip lays it out as one, with the
+     * property captioned above the value. A rule condition is a name with no value
+     * under it, so the name is the whole chip. Implements `ConditionChip`.
+     * @private 
+     */
+    interface HTMLLimebbRuleConditionChipElement extends Components.LimebbRuleConditionChip, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLLimebbRuleConditionChipElementEventMap>(type: K, listener: (this: HTMLLimebbRuleConditionChipElement, ev: LimebbRuleConditionChipCustomEvent<HTMLLimebbRuleConditionChipElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLLimebbRuleConditionChipElementEventMap>(type: K, listener: (this: HTMLLimebbRuleConditionChipElement, ev: LimebbRuleConditionChipCustomEvent<HTMLLimebbRuleConditionChipElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLLimebbRuleConditionChipElement: {
+        prototype: HTMLLimebbRuleConditionChipElement;
+        new (): HTMLLimebbRuleConditionChipElement;
+    };
+    interface HTMLLimebbRuleConditionEditorElementEventMap {
+        "conditionChange": Rule;
     }
     /**
-     * Popover content for a rule-editor chip. Carries its own styles so
-     * they travel with the element when `limel-popover` portals it out of
-     * the rule-editor's shadow DOM.
+     * The editor `limebb-condition-tree` opens for one rule condition: whatever
+     * component the primitive named as its `configComponent`.
+     * The two sides speak about different things. The tree passes a whole condition
+     * and listens for `conditionChange`; a config component edits the reference's
+     * `args` and reports a plain `change`. Config components are registered by
+     * add-ons this repo does not own, so this side is the one that translates.
+     * @alpha 
      * @private 
      */
-    interface HTMLLimebbRuleChipPopoverElement extends Components.LimebbRuleChipPopover, HTMLStencilElement {
-        addEventListener<K extends keyof HTMLLimebbRuleChipPopoverElementEventMap>(type: K, listener: (this: HTMLLimebbRuleChipPopoverElement, ev: LimebbRuleChipPopoverCustomEvent<HTMLLimebbRuleChipPopoverElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    interface HTMLLimebbRuleConditionEditorElement extends Components.LimebbRuleConditionEditor, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLLimebbRuleConditionEditorElementEventMap>(type: K, listener: (this: HTMLLimebbRuleConditionEditorElement, ev: LimebbRuleConditionEditorCustomEvent<HTMLLimebbRuleConditionEditorElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
         addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
         addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
         addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
-        removeEventListener<K extends keyof HTMLLimebbRuleChipPopoverElementEventMap>(type: K, listener: (this: HTMLLimebbRuleChipPopoverElement, ev: LimebbRuleChipPopoverCustomEvent<HTMLLimebbRuleChipPopoverElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLLimebbRuleConditionEditorElementEventMap>(type: K, listener: (this: HTMLLimebbRuleConditionEditorElement, ev: LimebbRuleConditionEditorCustomEvent<HTMLLimebbRuleConditionEditorElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
         removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
         removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
         removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
     }
-    var HTMLLimebbRuleChipPopoverElement: {
-        prototype: HTMLLimebbRuleChipPopoverElement;
-        new (): HTMLLimebbRuleChipPopoverElement;
+    var HTMLLimebbRuleConditionEditorElement: {
+        prototype: HTMLLimebbRuleConditionEditorElement;
+        new (): HTMLLimebbRuleConditionEditorElement;
     };
     interface HTMLLimebbRuleEditorElementEventMap {
         "change": Rule | undefined;
     }
     /**
      * Tree editor for {@link Rule}.
-     * Renders a `Rule` value as a tree of nodes. Lets an author pick
-     * primitive refs in `all` / `any` groups, toggle negation, delete
-     * nodes, and edit per-primitive args via the editor declared on each
-     * primitive's metadata.
+     * Renders a `Rule` value as a `limebb-condition-tree`. Lets an author
+     * add primitive refs to `all` / `any` groups and to the negations of
+     * those two, nest groups, negate a single ref, delete nodes, and edit
+     * per-primitive args via the editor declared on each primitive's
+     * metadata.
+     * The tree owns every structural edit, and knows nothing about rules. A
+     * `Rule` reaches it through an adapter — see `condition-tree-adapter.ts`
+     * — which is also where the group negation the rule model writes as a
+     * `not` wrapper is folded into the combinator the tree shows.
      * The component is value-in / value-out. Pass `value` and listen for
      * `change`; persistence is the caller's concern.
      * Pass `availableContexts` to forward the list of context keys the
@@ -5272,7 +5385,8 @@ declare global {
         "limebb-percentage-visualizer": HTMLLimebbPercentageVisualizerElement;
         "limebb-property-selector": HTMLLimebbPropertySelectorElement;
         "limebb-rule-arg-filter-editor": HTMLLimebbRuleArgFilterEditorElement;
-        "limebb-rule-chip-popover": HTMLLimebbRuleChipPopoverElement;
+        "limebb-rule-condition-chip": HTMLLimebbRuleConditionChipElement;
+        "limebb-rule-condition-editor": HTMLLimebbRuleConditionEditorElement;
         "limebb-rule-editor": HTMLLimebbRuleEditorElement;
         "limebb-rule-gate": HTMLLimebbRuleGateElement;
         "limebb-summary-popover": HTMLLimebbSummaryPopoverElement;
@@ -5785,6 +5899,10 @@ declare namespace LocalJSX {
           * The kinds of condition a user can add, offered as a menu when the add button is pressed. The chosen item is passed to `adapter.createLeaf`.  Leave it unset when every condition in the tree is of the same kind: a blank one can simply be inserted, and its editor settles the rest, so pressing the button is the whole interaction. Set it when conditions come in kinds that have nothing in common — "the deal is worth more than 100 000", "the user belongs to a group", "it is the first day of the month" — where nothing can be inserted until the user says which.  The menu has to be rendered here rather than by the consumer, because the button it hangs from lives inside this component.
          */
         "addOptions"?: Array<MenuItem | ListSeparator>;
+        /**
+          * How to narrow `addOptions` as the user types, which is what puts a search field at the top of the add menu.  Worth setting as soon as the kinds on offer stop fitting on a screen — and a consumer whose kinds are contributed by add-ons cannot know that they still do. `addOptions` is still what the menu opens on, so an unsearched menu reads exactly as it did before.
+         */
+        "addSearcher"?: MenuSearcher;
         /**
           * Which combinators to offer in the group dropdowns, in the order given.  All four are offered by default. "Not all of the following" and "None of the following" are harder to reason about than the two they negate, so a consumer whose users would be better served without them passes `['all', 'any']`. A group that already uses a combinator left off this list still shows it, rather than misrepresenting itself as using one of the offered ones.
           * @default [         ...CONDITION_TREE_COMBINATORS,     ]
@@ -5843,6 +5961,10 @@ declare namespace LocalJSX {
           * Title of the condition, shown above the editor when there is a header to show at all.
          */
         "heading"?: string;
+        /**
+          * The condition's glyph, shown beside the heading. The same one the chip carries, so that the popover reads as the chip opened up rather than as somewhere else.
+         */
+        "icon"?: IconName;
         /**
           * Whether the condition is negated. `undefined` means the condition expresses its own polarity and no switch is offered.
          */
@@ -7955,50 +8077,124 @@ declare namespace LocalJSX {
         "value"?: RuleArgFilterEditorValue;
     }
     /**
-     * Popover content for a rule-editor chip. Carries its own styles so
-     * they travel with the element when `limel-popover` portals it out of
-     * the rule-editor's shadow DOM.
+     * A rule condition as a chip, in place of the `limebb-filter-chip` the tree
+     * draws by default.
+     * A filter condition is a sentence and that chip lays it out as one, with the
+     * property captioned above the value. A rule condition is a name with no value
+     * under it, so the name is the whole chip. Implements `ConditionChip`.
+     * @private 
+     */
+    interface LimebbRuleConditionChip {
+        /**
+          * @inheritdoc 
+          * @default false
+         */
+        "disabled"?: boolean;
+        /**
+          * The condition's glyph.
+         */
+        "icon"?: IconName;
+        /**
+          * The glyph's colour, which travels beside the name because `ConditionTreeChip.icon` has no room for it.
+         */
+        "iconColor"?: string;
+        /**
+          * @inheritdoc 
+          * @default false
+         */
+        "invalid"?: boolean;
+        /**
+          * The name of the condition.
+         */
+        "label"?: string;
+        /**
+          * Whether the condition is negated. The chip has to say so: the switch that sets it is out of sight inside the editor.
+          * @default false
+         */
+        "negated"?: boolean;
+        /**
+          * Emitted when the author asks for the condition to be deleted.
+         */
+        "onRemove"?: (event: LimebbRuleConditionChipCustomEvent<void>) => void;
+        /**
+          * Platform service provider. Unread, but declared so that the tree setting it does not leave it in the DOM as an attribute.
+         */
+        "platform"?: LimeWebComponentPlatform;
+        /**
+          * Deliberately not passed on to `limel-chip`, which would render it as a disabled button. A condition's arguments live behind this chip and nowhere else, so a chip that cannot be opened is a rule that cannot be read. It takes the delete control away instead — see `removable`.
+          * @inheritdoc 
+          * @default false
+         */
+        "readonly"?: boolean;
+        /**
+          * Whether the chip offers a control that deletes the condition. `readonly` overrules it here rather than in the caller, since withholding `readonly` from `limel-chip` also withholds the lock it puts on the cross.
+          * @default true
+         */
+        "removable"?: boolean;
+        /**
+          * Whether this condition's editor is the one currently open.
+          * @default false
+         */
+        "selected"?: boolean;
+    }
+    /**
+     * The editor `limebb-condition-tree` opens for one rule condition: whatever
+     * component the primitive named as its `configComponent`.
+     * The two sides speak about different things. The tree passes a whole condition
+     * and listens for `conditionChange`; a config component edits the reference's
+     * `args` and reports a plain `change`. Config components are registered by
+     * add-ons this repo does not own, so this side is the one that translates.
+     * @alpha 
      * @private 
      */
-    interface LimebbRuleChipPopover {
+    interface LimebbRuleConditionEditor {
         /**
-          * Bridges the rule editor's context across the `limel-popover` portal.
+          * The component the primitive declared for editing its args.
+         */
+        "configComponent"?: ComponentDescriptor;
+        /**
+          * Component context
          */
         "context"?: LimeWebComponentContext;
         /**
+          * @inheritdoc 
           * @default false
          */
         "disabled"?: boolean;
         /**
-          * Forwarded to the embedded config component so it can pull focus when this popover opens. The rule editor sets it only when the chip was just added via the picker, so clicking an existing chip does not steal focus. The component decides when it is ready to receive focus (e.g. after loading its own data).
+          * Forwarded so that component can take focus as it appears. Set only for a condition the author has just added.
           * @default false
          */
         "focusOnOpen"?: boolean;
         /**
-          * @default true
+          * Emitted with the whole condition, args and negation together, whenever the config component reports new args.
          */
-        "isMutable"?: boolean;
+        "onConditionChange"?: (event: LimebbRuleConditionEditorCustomEvent<Rule>) => void;
         /**
-          * @default false
+          * Platform service provider
          */
-        "isNegated"?: boolean;
-        "metadata"?: PrimitiveMetadata;
-        "onDeleteChip"?: (event: LimebbRuleChipPopoverCustomEvent<void>) => void;
-        "onNegate"?: (event: LimebbRuleChipPopoverCustomEvent<boolean>) => void;
-        "onUpdateArgs"?: (event: LimebbRuleChipPopoverCustomEvent<JsonValue>) => void;
         "platform"?: LimeWebComponentPlatform;
         /**
+          * @inheritdoc 
           * @default false
          */
         "readonly"?: boolean;
-        "refNode"?: RuleRef;
+        /**
+          * The condition being edited: a reference to a primitive, or the `not` around one.
+         */
+        "value"?: Rule;
     }
     /**
      * Tree editor for {@link Rule}.
-     * Renders a `Rule` value as a tree of nodes. Lets an author pick
-     * primitive refs in `all` / `any` groups, toggle negation, delete
-     * nodes, and edit per-primitive args via the editor declared on each
-     * primitive's metadata.
+     * Renders a `Rule` value as a `limebb-condition-tree`. Lets an author
+     * add primitive refs to `all` / `any` groups and to the negations of
+     * those two, nest groups, negate a single ref, delete nodes, and edit
+     * per-primitive args via the editor declared on each primitive's
+     * metadata.
+     * The tree owns every structural edit, and knows nothing about rules. A
+     * `Rule` reaches it through an adapter — see `condition-tree-adapter.ts`
+     * — which is also where the group negation the rule model writes as a
+     * `not` wrapper is folded into the combinator the tree shows.
      * The component is value-in / value-out. Pass `value` and listen for
      * `change`; persistence is the caller's concern.
      * Pass `availableContexts` to forward the list of context keys the
@@ -8040,7 +8236,7 @@ declare namespace LocalJSX {
          */
         "context"?: LimeWebComponentContext;
         /**
-          * Whether or not the current property is disabled The mutation UI is hidden when set. The args editor is rendered with `disabled` forwarded to it.
+          * Whether or not the current property is disabled Every control stays where it is, dimmed and inert, when set. The args editor is rendered with `disabled` forwarded to it.
           * @inheritdoc
          */
         "disabled"?: boolean;
@@ -8067,7 +8263,7 @@ declare namespace LocalJSX {
          */
         "modes"?: RuleEditorMode[];
         /**
-          * Emitted when the rule tree is mutated. Detail is the new rule, or `undefined` when the user has cleared the editor to an empty root group — callers can persist `undefined` as "no rule" without having to inspect the rule shape themselves.
+          * The edited rule, or nothing when the author has cleared it.  What comes out is what should go back in as `value` — see the note there on why the objects themselves matter.
          */
         "onChange"?: (event: LimebbRuleEditorCustomEvent<Rule | undefined>) => void;
         /**
@@ -8075,7 +8271,7 @@ declare namespace LocalJSX {
          */
         "platform"?: LimeWebComponentPlatform;
         /**
-          * Whether or not the current property is readonly The mutation UI (delete and negate toggles, add-group button) is hidden when set. The args editor for each ref is still rendered, with `readonly` forwarded to it.
+          * Whether or not the current property is readonly The controls that add, delete and negate are not rendered when set, leaving the rule to be read. The args editor for each ref is still rendered, with `readonly` forwarded to it.
           * @inheritdoc
          */
         "readonly"?: boolean;
@@ -8085,7 +8281,7 @@ declare namespace LocalJSX {
          */
         "required"?: boolean;
         /**
-          * The value of the current property
+          * The value of the current property The rule under edit. Hand back what `change` emitted, not a copy: which condition is open, which have been visited and what validation said about each are all tracked by object identity, so a deep-cloned rule reads as a different one that happens to look the same.
           * @inheritdoc
          */
         "value"?: Rule | undefined;
@@ -8539,6 +8735,7 @@ declare namespace LocalJSX {
         "open": boolean;
         "value": string;
         "heading": string;
+        "icon": IconName;
         "negated": boolean;
         "readonly": boolean;
         "disabled": boolean;
@@ -8797,12 +8994,21 @@ declare namespace LocalJSX {
         "required": boolean;
         "helperText": string;
     }
-    interface LimebbRuleChipPopoverAttributes {
-        "isNegated": boolean;
+    interface LimebbRuleConditionChipAttributes {
+        "label": string;
+        "icon": IconName;
+        "iconColor": string;
+        "negated": boolean;
+        "invalid": boolean;
+        "selected": boolean;
         "readonly": boolean;
         "disabled": boolean;
-        "isMutable": boolean;
+        "removable": boolean;
+    }
+    interface LimebbRuleConditionEditorAttributes {
         "focusOnOpen": boolean;
+        "readonly": boolean;
+        "disabled": boolean;
     }
     interface LimebbRuleEditorAttributes {
         "required": boolean;
@@ -8922,7 +9128,8 @@ declare namespace LocalJSX {
         "limebb-percentage-visualizer": Omit<LimebbPercentageVisualizer, keyof LimebbPercentageVisualizerAttributes> & { [K in keyof LimebbPercentageVisualizer & keyof LimebbPercentageVisualizerAttributes]?: LimebbPercentageVisualizer[K] } & { [K in keyof LimebbPercentageVisualizer & keyof LimebbPercentageVisualizerAttributes as `attr:${K}`]?: LimebbPercentageVisualizerAttributes[K] } & { [K in keyof LimebbPercentageVisualizer & keyof LimebbPercentageVisualizerAttributes as `prop:${K}`]?: LimebbPercentageVisualizer[K] };
         "limebb-property-selector": Omit<LimebbPropertySelector, keyof LimebbPropertySelectorAttributes> & { [K in keyof LimebbPropertySelector & keyof LimebbPropertySelectorAttributes]?: LimebbPropertySelector[K] } & { [K in keyof LimebbPropertySelector & keyof LimebbPropertySelectorAttributes as `attr:${K}`]?: LimebbPropertySelectorAttributes[K] } & { [K in keyof LimebbPropertySelector & keyof LimebbPropertySelectorAttributes as `prop:${K}`]?: LimebbPropertySelector[K] };
         "limebb-rule-arg-filter-editor": LimebbRuleArgFilterEditor;
-        "limebb-rule-chip-popover": Omit<LimebbRuleChipPopover, keyof LimebbRuleChipPopoverAttributes> & { [K in keyof LimebbRuleChipPopover & keyof LimebbRuleChipPopoverAttributes]?: LimebbRuleChipPopover[K] } & { [K in keyof LimebbRuleChipPopover & keyof LimebbRuleChipPopoverAttributes as `attr:${K}`]?: LimebbRuleChipPopoverAttributes[K] } & { [K in keyof LimebbRuleChipPopover & keyof LimebbRuleChipPopoverAttributes as `prop:${K}`]?: LimebbRuleChipPopover[K] };
+        "limebb-rule-condition-chip": Omit<LimebbRuleConditionChip, keyof LimebbRuleConditionChipAttributes> & { [K in keyof LimebbRuleConditionChip & keyof LimebbRuleConditionChipAttributes]?: LimebbRuleConditionChip[K] } & { [K in keyof LimebbRuleConditionChip & keyof LimebbRuleConditionChipAttributes as `attr:${K}`]?: LimebbRuleConditionChipAttributes[K] } & { [K in keyof LimebbRuleConditionChip & keyof LimebbRuleConditionChipAttributes as `prop:${K}`]?: LimebbRuleConditionChip[K] };
+        "limebb-rule-condition-editor": Omit<LimebbRuleConditionEditor, keyof LimebbRuleConditionEditorAttributes> & { [K in keyof LimebbRuleConditionEditor & keyof LimebbRuleConditionEditorAttributes]?: LimebbRuleConditionEditor[K] } & { [K in keyof LimebbRuleConditionEditor & keyof LimebbRuleConditionEditorAttributes as `attr:${K}`]?: LimebbRuleConditionEditorAttributes[K] } & { [K in keyof LimebbRuleConditionEditor & keyof LimebbRuleConditionEditorAttributes as `prop:${K}`]?: LimebbRuleConditionEditor[K] };
         "limebb-rule-editor": Omit<LimebbRuleEditor, keyof LimebbRuleEditorAttributes> & { [K in keyof LimebbRuleEditor & keyof LimebbRuleEditorAttributes]?: LimebbRuleEditor[K] } & { [K in keyof LimebbRuleEditor & keyof LimebbRuleEditorAttributes as `attr:${K}`]?: LimebbRuleEditorAttributes[K] } & { [K in keyof LimebbRuleEditor & keyof LimebbRuleEditorAttributes as `prop:${K}`]?: LimebbRuleEditor[K] };
         "limebb-rule-gate": LimebbRuleGate;
         "limebb-summary-popover": Omit<LimebbSummaryPopover, keyof LimebbSummaryPopoverAttributes> & { [K in keyof LimebbSummaryPopover & keyof LimebbSummaryPopoverAttributes]?: LimebbSummaryPopover[K] } & { [K in keyof LimebbSummaryPopover & keyof LimebbSummaryPopoverAttributes as `attr:${K}`]?: LimebbSummaryPopoverAttributes[K] } & { [K in keyof LimebbSummaryPopover & keyof LimebbSummaryPopoverAttributes as `prop:${K}`]?: LimebbSummaryPopover[K] };
@@ -9773,18 +9980,36 @@ declare module "@stencil/core" {
              */
             "limebb-rule-arg-filter-editor": LocalJSX.IntrinsicElements["limebb-rule-arg-filter-editor"] & JSXBase.HTMLAttributes<HTMLLimebbRuleArgFilterEditorElement>;
             /**
-             * Popover content for a rule-editor chip. Carries its own styles so
-             * they travel with the element when `limel-popover` portals it out of
-             * the rule-editor's shadow DOM.
+             * A rule condition as a chip, in place of the `limebb-filter-chip` the tree
+             * draws by default.
+             * A filter condition is a sentence and that chip lays it out as one, with the
+             * property captioned above the value. A rule condition is a name with no value
+             * under it, so the name is the whole chip. Implements `ConditionChip`.
+             * @private 
+             */
+            "limebb-rule-condition-chip": LocalJSX.IntrinsicElements["limebb-rule-condition-chip"] & JSXBase.HTMLAttributes<HTMLLimebbRuleConditionChipElement>;
+            /**
+             * The editor `limebb-condition-tree` opens for one rule condition: whatever
+             * component the primitive named as its `configComponent`.
+             * The two sides speak about different things. The tree passes a whole condition
+             * and listens for `conditionChange`; a config component edits the reference's
+             * `args` and reports a plain `change`. Config components are registered by
+             * add-ons this repo does not own, so this side is the one that translates.
+             * @alpha 
              * @private 
              */
-            "limebb-rule-chip-popover": LocalJSX.IntrinsicElements["limebb-rule-chip-popover"] & JSXBase.HTMLAttributes<HTMLLimebbRuleChipPopoverElement>;
+            "limebb-rule-condition-editor": LocalJSX.IntrinsicElements["limebb-rule-condition-editor"] & JSXBase.HTMLAttributes<HTMLLimebbRuleConditionEditorElement>;
             /**
              * Tree editor for {@link Rule}.
-             * Renders a `Rule` value as a tree of nodes. Lets an author pick
-             * primitive refs in `all` / `any` groups, toggle negation, delete
-             * nodes, and edit per-primitive args via the editor declared on each
-             * primitive's metadata.
+             * Renders a `Rule` value as a `limebb-condition-tree`. Lets an author
+             * add primitive refs to `all` / `any` groups and to the negations of
+             * those two, nest groups, negate a single ref, delete nodes, and edit
+             * per-primitive args via the editor declared on each primitive's
+             * metadata.
+             * The tree owns every structural edit, and knows nothing about rules. A
+             * `Rule` reaches it through an adapter — see `condition-tree-adapter.ts`
+             * — which is also where the group negation the rule model writes as a
+             * `not` wrapper is folded into the combinator the tree shows.
              * The component is value-in / value-out. Pass `value` and listen for
              * `change`; persistence is the caller's concern.
              * Pass `availableContexts` to forward the list of context keys the