@praxisui/table-rule-builder 8.0.0-beta.2 → 8.0.0-beta.21

package/README.md

@@ -31,6 +31,44 @@ Peers (Angular v20): `@angular/core`, `@angular/common`, `@angular/forms`, `@ang
 - Contrato runtime atual: animação é suportada em `rowConditionalRenderers` e `columns[].conditionalRenderers` (com precedência `rule.animation > rule.renderer.animation` e first-match por efeito real).
 - Tipos: `RuleEffectDefinition`, `RuleScope`
 
+## Conditional effects alignment
+
+`RuleEffectsPanelComponent` edits one aggregate `RuleEffectDefinition` because a visual rule can combine style, layout, icon, background, animation and tooltip in a single authoring surface.
+
+When the panel is embedded by `@praxisui/table`, the table rule entry stores the visual payload as `effects: RuleEffectDefinition[]`. That keeps the persisted rule aligned with the platform shape `PraxisRuntimeConditionalEffectRule<RuleEffectDefinition>` while preserving `@praxisui/table` as the owner of table placement into `rowConditionalRenderers`, `columns[].conditionalRenderers` and conditional style surfaces.
+
+Existing singular `effects: RuleEffectDefinition` payloads are accepted on load and normalized back to the canonical array on apply.
+
 ## Testes
 
 - Target oficial no workspace: `ng test praxis-table-rule-builder --watch=false --browsers=ChromeHeadless`
+
+## Agentic Authoring Contract
+
+`PRAXIS_TABLE_RULE_BUILDER_AUTHORING_MANIFEST` is the governed AI contract for this package and is exported from the public API.
+
+The manifest owns only table rule visual effects:
+
+- rule identity and condition/effect attachment
+- supported effect categories from `EffectRegistryService`
+- built-in `DEFAULT_EFFECT_PRESETS`
+- semantic animation presets and aliases
+- fail-closed conversion through `toCellClassAndStyle(...)`
+
+It does not own table column, datasource, renderer placement or `TableConfigV2` semantics. Those changes must delegate to the `praxis-table` authoring manifest.
+Operations that mutate the effect panel write canonical runtime surfaces: `RuleEffectDefinition`, `RuleEffectDefinition.animation`, `RuleEffectsPanelComponent.effectsForm`, `valueChange` and explicit `delegatedAuthoringOperations`.
+The contract does not persist a local `ruleEffects.rules` tree.
+
+Governed operation families:
+
+- `rule.add`
+- `rule.remove`
+- `condition.set`
+- `effect.add`
+- `effect.update`
+- `effect.remove`
+- `preset.apply`
+- `animation.set`
+- `tableIntegration.delegate`
+
+Stable identities are `ruleId`, `effectId` and `presetKey`; array indexes are not canonical identities. Destructive rule/effect removal requires explicit confirmation.

package/fesm2022/praxisui-table-rule-builder.mjs

@@ -22,6 +22,7 @@ import * as i4 from '@angular/material/button-toggle';
 import { MatButtonToggleModule } from '@angular/material/button-toggle';
 import * as i6 from '@angular/material/slider';
 import { MatSliderModule } from '@angular/material/slider';
+import { PdxColorPickerComponent } from '@praxisui/dynamic-fields';
 
 const RULE_ANIMATION_TYPE_SET = new Set([
     'pulse',
@@ -240,15 +241,27 @@ class EstiloEditorComponent {
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: EstiloEditorComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
     static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.3.17", type: EstiloEditorComponent, isStandalone: true, selector: "praxis-effects-estilo-editor", inputs: { group: "group" }, ngImport: i0, template: `
     <div class="estilo-grid" role="group" aria-label="Editor de estilo" [formGroup]="group">
-      <mat-form-field appearance="outline">
-        <mat-label>Cor do texto</mat-label>
-        <input matInput type="text" formControlName="color" placeholder="#E7ECF6" />
-      </mat-form-field>
+      <pdx-color-picker
+        label="Cor do texto"
+        formControlName="color"
+        [format]="'hex'"
+        [preview]="true"
+        [views]="['gradient', 'palette']"
+        [paletteSettings]="{ preset: 'material', columns: 8 }"
+        [gradientSettings]="{ showOpacity: false, channel: 'hsv' }"
+        [popupSettings]="{ width: 340 }"
+      ></pdx-color-picker>
 
-      <mat-form-field appearance="outline">
-        <mat-label>Cor de fundo do texto</mat-label>
-        <input matInput type="text" formControlName="bgColor" placeholder="#122033" />
-      </mat-form-field>
+      <pdx-color-picker
+        label="Cor de fundo do texto"
+        formControlName="bgColor"
+        [format]="'hex'"
+        [preview]="true"
+        [views]="['gradient', 'palette']"
+        [paletteSettings]="{ preset: 'material', columns: 8 }"
+        [gradientSettings]="{ showOpacity: false, channel: 'hsv' }"
+        [popupSettings]="{ width: 340 }"
+      ></pdx-color-picker>
 
       <div class="toggles">
         <mat-button-toggle-group multiple>
@@ -289,7 +302,7 @@ class EstiloEditorComponent {
         </label>
       </div>
     </div>
-  `, isInline: true, styles: [".estilo-grid{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:12px;align-items:start}.toggles{display:flex;align-items:center;gap:8px}.sliders{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:12px}.slider{display:flex;flex-direction:column;gap:6px}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1.NgSelectOption, selector: "option", inputs: ["ngValue", "value"] }, { kind: "directive", type: i1.ɵNgSelectMultipleOption, selector: "option", inputs: ["ngValue", "value"] }, { kind: "directive", type: i1.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i1.SelectControlValueAccessor, selector: "select:not([multiple])[formControlName],select:not([multiple])[formControl],select:not([multiple])[ngModel]", inputs: ["compareWith"] }, { kind: "directive", type: i1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i1.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "ngmodule", type: MatFormFieldModule }, { kind: "component", type: i2.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i2.MatLabel, selector: "mat-label" }, { kind: "ngmodule", type: MatInputModule }, { kind: "directive", type: i3.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly", "disabledInteractive"], exportAs: ["matInput"] }, { kind: "ngmodule", type: MatButtonToggleModule }, { kind: "directive", type: i4.MatButtonToggleGroup, selector: "mat-button-toggle-group", inputs: ["appearance", "name", "vertical", "value", "multiple", "disabled", "disabledInteractive", "hideSingleSelectionIndicator", "hideMultipleSelectionIndicator"], outputs: ["valueChange", "change"], exportAs: ["matButtonToggleGroup"] }, { kind: "component", type: i4.MatButtonToggle, selector: "mat-button-toggle", inputs: ["aria-label", "aria-labelledby", "id", "name", "value", "tabIndex", "disableRipple", "appearance", "checked", "disabled", "disabledInteractive"], outputs: ["change"], exportAs: ["matButtonToggle"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i5.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: MatSliderModule }, { kind: "component", type: i6.MatSlider, selector: "mat-slider", inputs: ["disabled", "discrete", "showTickMarks", "min", "color", "disableRipple", "max", "step", "displayWith"], exportAs: ["matSlider"] }, { kind: "directive", type: i6.MatSliderThumb, selector: "input[matSliderThumb]", inputs: ["value"], outputs: ["valueChange", "dragStart", "dragEnd"], exportAs: ["matSliderThumb"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+  `, isInline: true, styles: [".estilo-grid{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:12px;align-items:start}.toggles{display:flex;align-items:center;gap:8px}.sliders{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:12px}.slider{display:flex;flex-direction:column;gap:6px}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1.NgSelectOption, selector: "option", inputs: ["ngValue", "value"] }, { kind: "directive", type: i1.ɵNgSelectMultipleOption, selector: "option", inputs: ["ngValue", "value"] }, { kind: "directive", type: i1.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i1.SelectControlValueAccessor, selector: "select:not([multiple])[formControlName],select:not([multiple])[formControl],select:not([multiple])[ngModel]", inputs: ["compareWith"] }, { kind: "directive", type: i1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i1.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "ngmodule", type: MatFormFieldModule }, { kind: "component", type: i2.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i2.MatLabel, selector: "mat-label" }, { kind: "ngmodule", type: MatInputModule }, { kind: "directive", type: i3.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly", "disabledInteractive"], exportAs: ["matInput"] }, { kind: "ngmodule", type: MatButtonToggleModule }, { kind: "directive", type: i4.MatButtonToggleGroup, selector: "mat-button-toggle-group", inputs: ["appearance", "name", "vertical", "value", "multiple", "disabled", "disabledInteractive", "hideSingleSelectionIndicator", "hideMultipleSelectionIndicator"], outputs: ["valueChange", "change"], exportAs: ["matButtonToggleGroup"] }, { kind: "component", type: i4.MatButtonToggle, selector: "mat-button-toggle", inputs: ["aria-label", "aria-labelledby", "id", "name", "value", "tabIndex", "disableRipple", "appearance", "checked", "disabled", "disabledInteractive"], outputs: ["change"], exportAs: ["matButtonToggle"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i5.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: MatSliderModule }, { kind: "component", type: i6.MatSlider, selector: "mat-slider", inputs: ["disabled", "discrete", "showTickMarks", "min", "color", "disableRipple", "max", "step", "displayWith"], exportAs: ["matSlider"] }, { kind: "directive", type: i6.MatSliderThumb, selector: "input[matSliderThumb]", inputs: ["value"], outputs: ["valueChange", "dragStart", "dragEnd"], exportAs: ["matSliderThumb"] }, { kind: "component", type: PdxColorPickerComponent, selector: "pdx-color-picker", inputs: ["actionsLayout", "activeView", "adaptiveMode", "adaptiveTitle", "adaptiveSubtitle", "clearButton", "disabledMode", "readonlyMode", "visible", "presentationMode", "fillMode", "format", "gradientSettings", "icon", "iconClass", "svgIcon", "paletteSettings", "popupSettings", "preview", "rounded", "size", "tabindex", "views", "maxRecent", "showRecent"], outputs: ["valueChange", "open", "close", "cancel", "activeViewChange", "activeColorClick", "focusEvent", "blurEvent"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: EstiloEditorComponent, decorators: [{
             type: Component,
@@ -301,17 +314,30 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImpo
                         MatButtonToggleModule,
                         MatIconModule,
                         MatSliderModule,
+                        PdxColorPickerComponent,
                     ], template: `
     <div class="estilo-grid" role="group" aria-label="Editor de estilo" [formGroup]="group">
-      <mat-form-field appearance="outline">
-        <mat-label>Cor do texto</mat-label>
-        <input matInput type="text" formControlName="color" placeholder="#E7ECF6" />
-      </mat-form-field>
+      <pdx-color-picker
+        label="Cor do texto"
+        formControlName="color"
+        [format]="'hex'"
+        [preview]="true"
+        [views]="['gradient', 'palette']"
+        [paletteSettings]="{ preset: 'material', columns: 8 }"
+        [gradientSettings]="{ showOpacity: false, channel: 'hsv' }"
+        [popupSettings]="{ width: 340 }"
+      ></pdx-color-picker>
 
-      <mat-form-field appearance="outline">
-        <mat-label>Cor de fundo do texto</mat-label>
-        <input matInput type="text" formControlName="bgColor" placeholder="#122033" />
-      </mat-form-field>
+      <pdx-color-picker
+        label="Cor de fundo do texto"
+        formControlName="bgColor"
+        [format]="'hex'"
+        [preview]="true"
+        [views]="['gradient', 'palette']"
+        [paletteSettings]="{ preset: 'material', columns: 8 }"
+        [gradientSettings]="{ showOpacity: false, channel: 'hsv' }"
+        [popupSettings]="{ width: 340 }"
+      ></pdx-color-picker>
 
       <div class="toggles">
         <mat-button-toggle-group multiple>
@@ -1306,8 +1332,408 @@ function toCellClassAndStyle(effect, options) {
     return { classList, style };
 }
 
+const ruleAddSchema = {
+    type: 'object',
+    required: ['ruleId', 'scope'],
+    properties: {
+        ruleId: { type: 'string' },
+        scope: { enum: ['cell', 'row', 'column', 'table'] },
+        columnKey: { type: 'string' },
+        condition: { type: 'object' },
+        effect: { type: 'object' },
+        insertAfterRuleId: { type: 'string' },
+    },
+};
+const ruleRemoveSchema = {
+    type: 'object',
+    required: ['ruleId'],
+    properties: {
+        ruleId: { type: 'string' },
+        removeEffects: { type: 'boolean' },
+        preserveCondition: { type: 'boolean' },
+    },
+};
+const conditionSetSchema = {
+    type: 'object',
+    required: ['ruleId', 'condition'],
+    properties: {
+        ruleId: { type: 'string' },
+        condition: { type: 'object' },
+        scope: { enum: ['cell', 'row', 'column', 'table'] },
+        columnKey: { type: 'string' },
+        mode: { enum: ['replace', 'merge'] },
+    },
+};
+const effectAddSchema = {
+    type: 'object',
+    required: ['ruleId', 'effectId', 'effectType'],
+    properties: {
+        ruleId: { type: 'string' },
+        effectId: { type: 'string' },
+        effectType: {
+            enum: ['estilo', 'layout', 'icone', 'fundo', 'animacao', 'tooltip'],
+        },
+        payload: { type: 'object' },
+    },
+};
+const effectUpdateSchema = {
+    type: 'object',
+    required: ['ruleId', 'effectId', 'payload'],
+    properties: {
+        ruleId: { type: 'string' },
+        effectId: { type: 'string' },
+        payload: { type: 'object' },
+        mode: { enum: ['replace', 'merge'] },
+    },
+};
+const effectRemoveSchema = {
+    type: 'object',
+    required: ['ruleId', 'effectId'],
+    properties: {
+        ruleId: { type: 'string' },
+        effectId: { type: 'string' },
+        removeEmptyRule: { type: 'boolean' },
+    },
+};
+const presetApplySchema = {
+    type: 'object',
+    required: ['ruleId', 'presetKey'],
+    properties: {
+        ruleId: { type: 'string' },
+        presetKey: { enum: ['aprovado', 'alerta', 'erro', 'info'] },
+        scope: { enum: ['cell', 'row', 'column', 'table'] },
+        mergeWithExisting: { type: 'boolean' },
+    },
+};
+const animationSetSchema = {
+    type: 'object',
+    required: ['ruleId', 'animation'],
+    properties: {
+        ruleId: { type: 'string' },
+        effectId: { type: 'string' },
+        animation: {
+            type: 'object',
+            properties: {
+                enabled: { type: 'boolean' },
+                preset: {
+                    enum: [
+                        'info-soft',
+                        'success-confirm',
+                        'warning-attention',
+                        'critical-alert',
+                        'audit-review',
+                        'sync-pending',
+                        'sla-warning',
+                        'sla-breach',
+                        'risk-elevated',
+                        'risk-critical',
+                        'audit-warning',
+                        'sync-warning',
+                    ],
+                },
+                type: { enum: ['pulse', 'blink', 'grow', 'fade', 'slide-in', 'border-pulse'] },
+                trigger: {
+                    enum: [
+                        'onChange',
+                        'onAppear',
+                        'onHover',
+                        'onConditionEnter',
+                        'onConditionExit',
+                        'onDataRefresh',
+                    ],
+                },
+                repeat: {},
+                durationMs: { type: 'number' },
+                delayMs: { type: 'number' },
+                intensity: { enum: ['subtle', 'normal', 'strong'] },
+            },
+        },
+    },
+};
+const tableDelegateSchema = {
+    type: 'object',
+    required: ['tableOperationId', 'reason'],
+    properties: {
+        tableOperationId: { type: 'string' },
+        reason: { type: 'string' },
+        tableTarget: { type: 'object' },
+        tableParams: { type: 'object' },
+    },
+};
+const PRAXIS_TABLE_RULE_BUILDER_AUTHORING_MANIFEST = {
+    schemaVersion: '1.0.0',
+    componentId: 'praxis-table-rule-builder',
+    ownerPackage: '@praxisui/table-rule-builder',
+    configSchemaId: 'RuleEffectDefinition',
+    manifestVersion: '1.0.0',
+    runtimeInputs: [
+        { name: 'scope', type: 'RuleScope', description: 'Effect scope: cell, row, column or table.' },
+        { name: 'value', type: 'RuleEffectDefinition | undefined', description: 'Initial effect definition hydrated into the panel form.' },
+        { name: 'valueChange', type: 'RuleEffectDefinition', description: 'Debounced normalized effect payload emitted by the editor.' },
+        { name: 'apply', type: 'void', description: 'Emitted when the user applies the current effect payload.' },
+        { name: 'reset', type: 'void', description: 'Emitted when the user resets the panel form.' },
+    ],
+    editableTargets: [
+        { kind: 'rule', resolver: 'table-rule-by-stable-id', description: 'Table conditional rule entry keyed by stable rule id before it is passed to praxis-table.' },
+        { kind: 'condition', resolver: 'table-rule-condition-by-rule-id', description: 'Structured condition payload evaluated against table row/column context.' },
+        { kind: 'effect', resolver: 'rule-effect-by-rule-and-effect-id', description: 'Visual effect payload inside a rule, mapped to RuleEffectDefinition.' },
+        { kind: 'preset', resolver: 'default-effect-preset-by-key', description: 'Built-in semantic effect preset from DEFAULT_EFFECT_PRESETS.' },
+        { kind: 'animation', resolver: 'rule-animation-by-rule-and-effect-id', description: 'Animation preset, alias or override resolved through animation-presets.' },
+        { kind: 'tableDelegation', resolver: 'praxis-table-authoring-operation', description: 'Explicit delegation boundary for table-owned configuration changes.' },
+    ],
+    operations: [
+        {
+            operationId: 'rule.add',
+            title: 'Add table visual rule',
+            scope: 'rule',
+            targetKind: 'rule',
+            target: { kind: 'rule', resolver: 'table-rule-by-stable-id', ambiguityPolicy: 'fail', required: true },
+            inputSchema: ruleAddSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'table-rule-builder-rule-add', handlerContract: {
+                        reads: ['RuleEffectsPanelComponent.scope', 'RuleEffectDefinition', 'praxis-table rowConditionalRenderers', 'praxis-table columns[].conditionalRenderers'],
+                        writes: ['delegatedAuthoringOperations', 'RuleEffectDefinition'],
+                        identityKeys: ['ruleId'],
+                        inputSchema: ruleAddSchema,
+                        failureModes: ['duplicate-rule-id', 'unsupported-scope', 'column-not-found', 'condition-invalid', 'effect-registry-miss'],
+                        description: 'Creates a stable table visual rule and keeps table-owned renderer placement delegated to praxis-table.',
+                    } }],
+            validators: ['rule-id-unique', 'scope-supported', 'condition-table-context-valid', 'effect-registry-supported', 'table-owned-config-delegated'],
+            affectedPaths: ['delegatedAuthoringOperations', 'RuleEffectDefinition'],
+            submissionImpact: 'config-only',
+            preconditions: ['rule-effects-panel-loaded', 'table-authoring-context-known'],
+            destructive: false,
+            requiresConfirmation: false,
+        },
+        {
+            operationId: 'rule.remove',
+            title: 'Remove table visual rule',
+            scope: 'rule',
+            targetKind: 'rule',
+            target: { kind: 'rule', resolver: 'table-rule-by-stable-id', ambiguityPolicy: 'fail', required: true },
+            inputSchema: ruleRemoveSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'table-rule-builder-rule-remove', handlerContract: {
+                        reads: ['ruleEffects.rules', 'ruleEffects.rules[].effect', 'ruleEffects.rules[].condition'],
+                        writes: ['delegatedAuthoringOperations'],
+                        identityKeys: ['ruleId'],
+                        inputSchema: ruleRemoveSchema,
+                        failureModes: ['rule-not-found', 'destructive-removal-not-confirmed', 'orphaned-table-renderer', 'condition-preserve-not-supported'],
+                        description: 'Removes a governed visual rule by id with confirmation because conditions and effects can be lost.',
+                    } }],
+            destructive: true,
+            requiresConfirmation: true,
+            validators: ['rule-exists', 'destructive-removal-confirmed', 'table-renderer-references-clean', 'table-owned-config-delegated'],
+            affectedPaths: ['delegatedAuthoringOperations'],
+            submissionImpact: 'config-only',
+            preconditions: ['rule-effects-panel-loaded', 'explicit-confirmation-provided'],
+        },
+        {
+            operationId: 'condition.set',
+            title: 'Set table rule condition',
+            scope: 'rule',
+            targetKind: 'condition',
+            target: { kind: 'condition', resolver: 'table-rule-condition-by-rule-id', ambiguityPolicy: 'fail', required: true },
+            inputSchema: conditionSetSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'table-rule-builder-condition-set', handlerContract: {
+                        reads: ['ruleEffects.rules', 'praxis-table dataSource fields', 'praxis-table columns'],
+                        writes: ['delegatedAuthoringOperations'],
+                        identityKeys: ['ruleId'],
+                        inputSchema: conditionSetSchema,
+                        failureModes: ['rule-not-found', 'condition-invalid', 'field-not-in-table-context', 'column-not-found'],
+                        description: 'Applies a structured table row/column condition without creating a parallel table DSL.',
+                    } }],
+            validators: ['rule-exists', 'condition-table-context-valid', 'condition-fields-known', 'condition-operators-supported'],
+            affectedPaths: ['delegatedAuthoringOperations'],
+            submissionImpact: 'config-only',
+            preconditions: ['rule-effects-panel-loaded', 'table-authoring-context-known'],
+            destructive: false,
+            requiresConfirmation: false,
+        },
+        {
+            operationId: 'effect.add',
+            title: 'Add visual effect to rule',
+            scope: 'skin',
+            targetKind: 'effect',
+            target: { kind: 'effect', resolver: 'rule-effect-by-rule-and-effect-id', ambiguityPolicy: 'fail', required: true },
+            inputSchema: effectAddSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'table-rule-builder-effect-add', handlerContract: {
+                        reads: ['EffectRegistryService.list', 'RuleEffectDefinition', 'toCellClassAndStyle'],
+                        writes: ['RuleEffectDefinition'],
+                        identityKeys: ['ruleId', 'effectId'],
+                        inputSchema: effectAddSchema,
+                        failureModes: ['rule-not-found', 'duplicate-effect-id', 'unsupported-effect-type', 'unsafe-style-value'],
+                        description: 'Adds a governed visual effect whose type is backed by the effect registry and RuleEffectDefinition.',
+                    } }],
+            validators: ['rule-exists', 'effect-id-unique', 'effect-registry-supported', 'style-values-safe', 'preview-class-not-persisted'],
+            affectedPaths: ['RuleEffectDefinition'],
+            submissionImpact: 'visual-only',
+            preconditions: ['rule-effects-panel-loaded', 'effect-registry-initialized'],
+            destructive: false,
+            requiresConfirmation: false,
+        },
+        {
+            operationId: 'effect.update',
+            title: 'Update visual effect payload',
+            scope: 'skin',
+            targetKind: 'effect',
+            target: { kind: 'effect', resolver: 'rule-effect-by-rule-and-effect-id', ambiguityPolicy: 'fail', required: true },
+            inputSchema: effectUpdateSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'table-rule-builder-effect-update', handlerContract: {
+                        reads: ['ruleEffects.rules[].effect', 'EffectRegistryService.list', 'toCellClassAndStyle'],
+                        writes: ['RuleEffectDefinition'],
+                        identityKeys: ['ruleId', 'effectId'],
+                        inputSchema: effectUpdateSchema,
+                        failureModes: ['rule-not-found', 'effect-not-found', 'unsupported-effect-type', 'unsafe-style-value'],
+                        description: 'Updates a visual effect payload while preserving its stable effect id and registry-backed type.',
+                    } }],
+            validators: ['rule-exists', 'effect-exists', 'effect-registry-supported', 'style-values-safe', 'runtime-effect-compilable'],
+            affectedPaths: ['RuleEffectDefinition'],
+            submissionImpact: 'visual-only',
+            preconditions: ['rule-effects-panel-loaded', 'effect-registry-initialized'],
+            destructive: false,
+            requiresConfirmation: false,
+        },
+        {
+            operationId: 'effect.remove',
+            title: 'Remove visual effect from rule',
+            scope: 'skin',
+            targetKind: 'effect',
+            target: { kind: 'effect', resolver: 'rule-effect-by-rule-and-effect-id', ambiguityPolicy: 'fail', required: true },
+            inputSchema: effectRemoveSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'table-rule-builder-effect-remove', handlerContract: {
+                        reads: ['ruleEffects.rules', 'ruleEffects.rules[].effect'],
+                        writes: ['RuleEffectDefinition', 'delegatedAuthoringOperations'],
+                        identityKeys: ['ruleId', 'effectId'],
+                        inputSchema: effectRemoveSchema,
+                        failureModes: ['rule-not-found', 'effect-not-found', 'destructive-removal-not-confirmed', 'empty-rule-created'],
+                        description: 'Removes one visual effect and optionally removes the empty rule, requiring confirmation for destructive cleanup.',
+                    } }],
+            destructive: true,
+            requiresConfirmation: true,
+            validators: ['rule-exists', 'effect-exists', 'destructive-removal-confirmed', 'empty-rule-policy-valid'],
+            affectedPaths: ['RuleEffectDefinition', 'delegatedAuthoringOperations'],
+            submissionImpact: 'visual-only',
+            preconditions: ['rule-effects-panel-loaded', 'explicit-confirmation-provided'],
+        },
+        {
+            operationId: 'preset.apply',
+            title: 'Apply semantic effect preset',
+            scope: 'skin',
+            targetKind: 'preset',
+            target: { kind: 'preset', resolver: 'default-effect-preset-by-key', ambiguityPolicy: 'fail', required: true },
+            inputSchema: presetApplySchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'table-rule-builder-preset-apply', handlerContract: {
+                        reads: ['DEFAULT_EFFECT_PRESETS', 'RuleEffectsPanelComponent.applyPreset', 'RuleEffectDefinition'],
+                        writes: ['RuleEffectDefinition', 'RuleEffectsPanelComponent.effectsForm', 'valueChange'],
+                        identityKeys: ['ruleId', 'presetKey'],
+                        inputSchema: presetApplySchema,
+                        failureModes: ['rule-not-found', 'preset-not-found', 'scope-override-invalid', 'preset-effect-not-compilable'],
+                        description: 'Applies a built-in semantic preset and normalizes its scope through the rule effects panel.',
+                    } }],
+            validators: ['rule-exists', 'preset-key-known', 'preset-effect-compilable', 'scope-supported'],
+            affectedPaths: ['RuleEffectDefinition', 'RuleEffectsPanelComponent.effectsForm', 'valueChange'],
+            submissionImpact: 'visual-only',
+            preconditions: ['rule-effects-panel-loaded', 'default-presets-loaded'],
+            destructive: false,
+            requiresConfirmation: false,
+        },
+        {
+            operationId: 'animation.set',
+            title: 'Set rule animation',
+            scope: 'skin',
+            targetKind: 'animation',
+            target: { kind: 'animation', resolver: 'rule-animation-by-rule-and-effect-id', ambiguityPolicy: 'fail', required: true },
+            inputSchema: animationSetSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'table-rule-builder-animation-set', handlerContract: {
+                        reads: ['RULE_ANIMATION_PRESETS', 'RULE_ANIMATION_PRESET_ALIASES', 'resolveRuleAnimationConfig', 'RuleEffectDefinition.animation'],
+                        writes: ['RuleEffectDefinition.animation', 'RuleEffectsPanelComponent.effectsForm.animation', 'valueChange'],
+                        identityKeys: ['ruleId', 'effectId'],
+                        inputSchema: animationSetSchema,
+                        failureModes: ['rule-not-found', 'effect-not-found', 'animation-preset-unknown', 'animation-override-invalid', 'reduced-motion-policy-violated'],
+                        description: 'Sets a semantic animation preset or override that resolves fail-closed through the animation preset catalog.',
+                    } }],
+            validators: ['rule-exists', 'animation-preset-known', 'animation-alias-known', 'animation-override-valid', 'animation-runtime-supported'],
+            affectedPaths: ['RuleEffectDefinition.animation', 'RuleEffectsPanelComponent.effectsForm.animation', 'valueChange'],
+            submissionImpact: 'visual-only',
+            preconditions: ['rule-effects-panel-loaded', 'animation-presets-loaded'],
+            destructive: false,
+            requiresConfirmation: false,
+        },
+        {
+            operationId: 'tableIntegration.delegate',
+            title: 'Delegate table-owned configuration',
+            scope: 'global',
+            targetKind: 'tableDelegation',
+            target: { kind: 'tableDelegation', resolver: 'praxis-table-authoring-operation', ambiguityPolicy: 'fail', required: false },
+            inputSchema: tableDelegateSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'table-rule-builder-table-delegate', handlerContract: {
+                        reads: ['PRAXIS_TABLE_AUTHORING_MANIFEST', 'TableConfigV2', 'tableOperationId'],
+                        writes: ['delegatedAuthoringOperations'],
+                        identityKeys: ['tableOperationId'],
+                        inputSchema: tableDelegateSchema,
+                        failureModes: ['table-operation-not-found', 'table-target-invalid', 'attempted-local-table-config-write'],
+                        description: 'Records that table-owned config such as renderer placement, columns, ordering or data binding must route through praxis-table.',
+                    } }],
+            validators: ['table-manifest-operation-known', 'table-target-valid', 'no-local-table-config-write', 'table-owned-config-delegated'],
+            affectedPaths: ['delegatedAuthoringOperations'],
+            submissionImpact: 'none',
+            preconditions: ['praxis-table-manifest-available'],
+            destructive: false,
+            requiresConfirmation: false,
+        },
+    ],
+    validators: [
+        { validatorId: 'rule-id-unique', level: 'error', code: 'TABLE_RULE_ID_UNIQUE', description: 'Rule ids must be unique and stable.' },
+        { validatorId: 'scope-supported', level: 'error', code: 'TABLE_RULE_SCOPE_SUPPORTED', description: 'Rule scope must be one of cell, row, column or table.' },
+        { validatorId: 'condition-table-context-valid', level: 'error', code: 'TABLE_RULE_CONDITION_CONTEXT_VALID', description: 'Conditions must reference valid table row or column context.' },
+        { validatorId: 'effect-registry-supported', level: 'error', code: 'TABLE_RULE_EFFECT_REGISTRY_SUPPORTED', description: 'Effects must be backed by EffectRegistryService editor categories.' },
+        { validatorId: 'table-owned-config-delegated', level: 'error', code: 'TABLE_RULE_TABLE_CONFIG_DELEGATED', description: 'Table-owned configuration changes must delegate to praxis-table.' },
+        { validatorId: 'rule-exists', level: 'error', code: 'TABLE_RULE_EXISTS', description: 'The targeted rule must exist.' },
+        { validatorId: 'destructive-removal-confirmed', level: 'error', code: 'TABLE_RULE_DESTRUCTIVE_CONFIRMED', description: 'Destructive rule or effect removal requires explicit confirmation.' },
+        { validatorId: 'table-renderer-references-clean', level: 'error', code: 'TABLE_RULE_RENDERER_REFERENCES_CLEAN', description: 'Removing a rule must not leave stale table renderer references.' },
+        { validatorId: 'condition-fields-known', level: 'error', code: 'TABLE_RULE_CONDITION_FIELDS_KNOWN', description: 'Condition fields must exist in table row data or column metadata.' },
+        { validatorId: 'condition-operators-supported', level: 'error', code: 'TABLE_RULE_CONDITION_OPERATORS_SUPPORTED', description: 'Condition operators must be supported by table rule semantics.' },
+        { validatorId: 'effect-id-unique', level: 'error', code: 'TABLE_RULE_EFFECT_ID_UNIQUE', description: 'Effect ids must be unique within a rule.' },
+        { validatorId: 'style-values-safe', level: 'error', code: 'TABLE_RULE_STYLE_VALUES_SAFE', description: 'CSS class and style values must be safe for runtime rendering.' },
+        { validatorId: 'preview-class-not-persisted', level: 'error', code: 'TABLE_RULE_PREVIEW_CLASS_NOT_PERSISTED', description: 'Preview-only animation classes must not leak into persisted payload mapping.' },
+        { validatorId: 'effect-exists', level: 'error', code: 'TABLE_RULE_EFFECT_EXISTS', description: 'The targeted effect must exist.' },
+        { validatorId: 'runtime-effect-compilable', level: 'error', code: 'TABLE_RULE_RUNTIME_EFFECT_COMPILABLE', description: 'Effect payload must compile through toCellClassAndStyle or table renderer semantics.' },
+        { validatorId: 'empty-rule-policy-valid', level: 'warning', code: 'TABLE_RULE_EMPTY_RULE_POLICY_VALID', description: 'Removing the last effect must follow the requested empty-rule policy.' },
+        { validatorId: 'preset-key-known', level: 'error', code: 'TABLE_RULE_PRESET_KEY_KNOWN', description: 'Preset key must exist in DEFAULT_EFFECT_PRESETS.' },
+        { validatorId: 'preset-effect-compilable', level: 'error', code: 'TABLE_RULE_PRESET_EFFECT_COMPILABLE', description: 'Preset payload must compile to RuleEffectDefinition.' },
+        { validatorId: 'animation-preset-known', level: 'error', code: 'TABLE_RULE_ANIMATION_PRESET_KNOWN', description: 'Animation preset must be canonical or explicitly aliased.' },
+        { validatorId: 'animation-alias-known', level: 'error', code: 'TABLE_RULE_ANIMATION_ALIAS_KNOWN', description: 'Animation aliases must resolve to canonical presets.' },
+        { validatorId: 'animation-override-valid', level: 'error', code: 'TABLE_RULE_ANIMATION_OVERRIDE_VALID', description: 'Animation overrides must normalize to supported type, trigger, repeat and intensity values.' },
+        { validatorId: 'animation-runtime-supported', level: 'error', code: 'TABLE_RULE_ANIMATION_RUNTIME_SUPPORTED', description: 'Animation payload must be supported by row and column conditional renderers.' },
+        { validatorId: 'table-manifest-operation-known', level: 'error', code: 'TABLE_RULE_TABLE_OPERATION_KNOWN', description: 'Delegated table operation must exist in the praxis-table authoring manifest.' },
+        { validatorId: 'table-target-valid', level: 'error', code: 'TABLE_RULE_TABLE_TARGET_VALID', description: 'Delegated table target must be resolvable by praxis-table.' },
+        { validatorId: 'no-local-table-config-write', level: 'error', code: 'TABLE_RULE_NO_LOCAL_TABLE_CONFIG_WRITE', description: 'Rule builder operations must not write TableConfig directly.' },
+    ],
+    roundTripRequirements: [
+        'RuleEffectDefinition is the local source of truth for the effects panel.',
+        'Rules that affect rowConditionalRenderers or columns[].conditionalRenderers must delegate table-owned placement to praxis-table.',
+        'Rule and effect identity must use stable ruleId/effectId keys; array indexes are not canonical identities.',
+        'Animation presets and aliases must resolve through RULE_ANIMATION_PRESETS and RULE_ANIMATION_PRESET_ALIASES before persistence.',
+        'Preview-only animation classes must be omitted from persisted table payload mapping by using includeAnimationPreview: false.',
+        'Preset application must preserve the selected scope and emit a normalized RuleEffectDefinition through valueChange.',
+    ],
+    examples: [
+        { id: 'table-rule-add-row-warning', request: 'Add a row warning rule for overdue invoices.', operationId: 'rule.add', target: 'rule:overdue-warning', params: { ruleId: 'overdue-warning', scope: 'row', condition: { field: 'dueDate', operator: 'beforeToday' }, effect: { background: { color: 'rgba(255,193,7,0.12)' } } }, isPositive: true },
+        { id: 'table-rule-remove-obsolete', request: 'Remove the obsolete archived row rule.', operationId: 'rule.remove', target: 'rule:archived-obsolete', params: { ruleId: 'archived-obsolete', removeEffects: true }, isPositive: true },
+        { id: 'table-rule-condition-status-error', request: 'Make the rule apply when status is error.', operationId: 'condition.set', target: 'condition:status-error', params: { ruleId: 'status-error', condition: { field: 'status', operator: 'equals', value: 'error' } }, isPositive: true },
+        { id: 'table-rule-add-badge-effect', request: 'Add a warning badge to the status rule.', operationId: 'effect.add', target: 'effect:status-warning/badge', params: { ruleId: 'status-warning', effectId: 'badge', effectType: 'icone', payload: { icon: 'warning', badgeText: 'Attention' } }, isPositive: true },
+        { id: 'table-rule-update-background', request: 'Change the risk rule background color.', operationId: 'effect.update', target: 'effect:risk/background', params: { ruleId: 'risk', effectId: 'background', payload: { background: { color: 'rgba(239,83,80,0.10)' } }, mode: 'merge' }, isPositive: true },
+        { id: 'table-rule-remove-tooltip', request: 'Remove the tooltip effect from the audit rule.', operationId: 'effect.remove', target: 'effect:audit/tooltip', params: { ruleId: 'audit', effectId: 'tooltip' }, isPositive: true },
+        { id: 'table-rule-apply-alerta', request: 'Use the alerta preset on the SLA rule.', operationId: 'preset.apply', target: 'preset:alerta', params: { ruleId: 'sla', presetKey: 'alerta', scope: 'row', mergeWithExisting: true }, isPositive: true },
+        { id: 'table-rule-animation-critical', request: 'Make the SLA breach animation critical.', operationId: 'animation.set', target: 'animation:sla-breach', params: { ruleId: 'sla-breach', effectId: 'animation', animation: { preset: 'critical-alert' } }, isPositive: true },
+        { id: 'table-rule-delegate-column-renderer', request: 'Move this effect to the status column renderer.', operationId: 'tableIntegration.delegate', target: 'praxis-table:column-renderer', params: { tableOperationId: 'column.conditionalRenderer.set', reason: 'column renderer placement is owned by praxis-table', tableTarget: { columnKey: 'status' } }, isPositive: true },
+        { id: 'table-rule-reject-direct-table-column', request: 'Add a new table column from the rule builder.', operationId: 'tableIntegration.delegate', target: 'praxis-table:column.add', params: { tableOperationId: 'column.add', reason: 'column authoring belongs to praxis-table' }, isPositive: false },
+        { id: 'table-rule-reject-unknown-effect', request: 'Add a sparkle shader effect to rows.', operationId: 'effect.add', target: 'effect:sparkle', params: { ruleId: 'risk', effectId: 'sparkle', effectType: 'shader', payload: {} }, isPositive: false },
+        { id: 'table-rule-reject-unknown-animation', request: 'Use the earthquake animation preset.', operationId: 'animation.set', target: 'animation:earthquake', params: { ruleId: 'risk', effectId: 'animation', animation: { preset: 'earthquake' } }, isPositive: false },
+    ],
+};
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AnimacaoEditorComponent, DEFAULT_EFFECT_PRESETS, EffectRegistryService, EstiloEditorComponent, FundoEditorComponent, IconeBadgeEditorComponent, LayoutEditorComponent, RuleEffectsPanelComponent, TooltipEditorComponent, toCellClassAndStyle };
+export { AnimacaoEditorComponent, DEFAULT_EFFECT_PRESETS, EffectRegistryService, EstiloEditorComponent, FundoEditorComponent, IconeBadgeEditorComponent, LayoutEditorComponent, PRAXIS_TABLE_RULE_BUILDER_AUTHORING_MANIFEST, RuleEffectsPanelComponent, TooltipEditorComponent, toCellClassAndStyle };

package/index.d.ts

@@ -2,6 +2,7 @@ import * as i0 from '@angular/core';
 import { OnInit, OnDestroy, EventEmitter } from '@angular/core';
 import { FormGroup, FormBuilder } from '@angular/forms';
 import { Subject } from 'rxjs';
+import { ComponentAuthoringManifest } from '@praxisui/core';
 
 type RuleScope = 'cell' | 'row' | 'column' | 'table';
 type RuleAnimationPreset = 'info-soft' | 'success-confirm' | 'warning-attention' | 'critical-alert' | 'audit-review' | 'sync-pending' | 'sla-warning' | 'sla-breach' | 'risk-elevated' | 'risk-critical' | 'audit-warning' | 'sync-warning';
@@ -175,5 +176,7 @@ declare class TooltipEditorComponent {
     static ɵcmp: i0.ɵɵComponentDeclaration<TooltipEditorComponent, "praxis-effects-tooltip-editor", never, { "group": { "alias": "group"; "required": false; }; }, {}, never, never, true, never>;
 }
 
-export { AnimacaoEditorComponent, DEFAULT_EFFECT_PRESETS, EffectRegistryService, EstiloEditorComponent, FundoEditorComponent, IconeBadgeEditorComponent, LayoutEditorComponent, RuleEffectsPanelComponent, TooltipEditorComponent, toCellClassAndStyle };
+declare const PRAXIS_TABLE_RULE_BUILDER_AUTHORING_MANIFEST: ComponentAuthoringManifest;
+
+export { AnimacaoEditorComponent, DEFAULT_EFFECT_PRESETS, EffectRegistryService, EstiloEditorComponent, FundoEditorComponent, IconeBadgeEditorComponent, LayoutEditorComponent, PRAXIS_TABLE_RULE_BUILDER_AUTHORING_MANIFEST, RuleEffectsPanelComponent, TooltipEditorComponent, toCellClassAndStyle };
 export type { EffectEditorPlugin, RuleAnimationIntensity, RuleAnimationPreset, RuleAnimationRepeat, RuleAnimationTrigger, RuleAnimationType, RuleEffectDefinition, RuleScope };

package/package.json

@@ -1,12 +1,16 @@
 {
   "name": "@praxisui/table-rule-builder",
-  "version": "8.0.0-beta.2",
+  "version": "8.0.0-beta.21",
   "description": "Praxis Table Rule Builder: UI components and engine utils for table rules",
   "peerDependencies": {
     "@angular/common": "^20.0.0",
     "@angular/core": "^20.0.0",
     "@angular/forms": "^20.0.0",
-    "@angular/material": "^20.0.0"
+    "@angular/material": "^20.0.0",
+    "@praxisui/ai": "^8.0.0-beta.21",
+    "@praxisui/core": "^8.0.0-beta.21",
+    "@praxisui/dynamic-fields": "^8.0.0-beta.21",
+    "rxjs": "~7.8.0"
   },
   "dependencies": {
     "tslib": "^2.3.0"