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

package/README.md

@@ -34,3 +34,33 @@ Peers (Angular v20): `@angular/core`, `@angular/common`, `@angular/forms`, `@ang
 ## 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

@@ -1306,8 +1306,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,15 @@
 {
   "name": "@praxisui/table-rule-builder",
-  "version": "8.0.0-beta.2",
+  "version": "8.0.0-beta.20",
   "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.20",
+    "@praxisui/core": "^8.0.0-beta.20",
+    "rxjs": "~7.8.0"
   },
   "dependencies": {
     "tslib": "^2.3.0"