@praxisui/visual-builder 8.0.0-beta.11 → 8.0.0-beta.13

package/README.md

@@ -86,10 +86,38 @@ Use the canonical public services:
 
 Main exports available from `@praxisui/visual-builder`:
 
+- Agentic authoring: `PRAXIS_VISUAL_BUILDER_AUTHORING_MANIFEST`
 - Components: `RuleEditorComponent`, `RuleCanvasComponent`, `RuleNodeComponent`, `FieldConditionEditorComponent`, `ConditionalValidatorEditorComponent`, `CollectionValidatorEditorComponent`, `MetadataEditorComponent`, `JsonViewerComponent`, `ExportDialogComponent`, `VisualRuleBuilderComponent`, `TemplateGalleryComponent`, `TemplateEditorDialogComponent`, `TemplatePreviewDialogComponent`, `RuleListComponent`, `ContextVariableManagerComponent`
 - Services: `RuleBuilderService`, `ExportIntegrationService`, `WebhookIntegrationService`, `RuleTemplateService`, `RuleValidationService`, `RuleNodeRegistryService`, `ContextManagementService`, `FieldSchemaService`
 - Models/Types: `FieldSchema`, `RuleBuilderConfig`, `ArrayFieldSchema`, `ContextScope`, `ContextEntry`, `ContextValue`
 
+## Agentic Authoring Contract
+
+`PRAXIS_VISUAL_BUILDER_AUTHORING_MANIFEST` is the executable AI authoring contract for this package.
+
+The manifest governs visual graph and JSON Logic orchestration:
+
+- `node.add`
+- `node.remove`
+- `node.configure`
+- `edge.connect`
+- `edge.remove`
+- `variable.add`
+- `condition.set`
+- `effect.set`
+- `dsl.roundTrip.validate`
+
+Boundary rules:
+
+- `RuleBuilderState` is the visual source of truth
+- operations write canonical runtime paths under `RuleBuilderState`, `RuleBuilderConfig`, `RuleNodeRegistryService` and `ContextManagementService`
+- node ids and context variable scope/name are stable identities
+- graph edges must reference existing nodes and avoid cycles where required
+- conditions persist as JSON Logic objects, not JavaScript or legacy textual DSL
+- effects must be constrained by target property schemas and `RULE_PROPERTY_SCHEMA`
+- `dsl.roundTrip.validate` validates the JSON export/import path currently implemented by `RuleBuilderService`; form-config import remains supported but is not advertised as a round-trip export target by this operation
+- component-specific configuration belongs to child component manifests
+
 ## Legacy Note
 
 The old textual `ExpressionEditorComponent` and DSL validation path were removed from the canonical library surface. Legacy DSL migration material should not be used as a baseline for new integrations.

package/fesm2022/praxisui-visual-builder.mjs

@@ -9983,6 +9983,12 @@ class TargetSelectorComponent {
                 description: this.t('target.type.action.description', 'Botoes de acao.'),
                 icon: 'smart_button',
             },
+            {
+                id: 'visualBlock',
+                label: this.t('target.type.visualBlock.label', 'Bloco visual'),
+                description: this.t('target.type.visualBlock.description', 'Bloco editorial no layout.'),
+                icon: 'notes',
+            },
         ];
     }
     ngOnInit() {
@@ -10153,6 +10159,8 @@ class TargetSelectorComponent {
                 return this.targetSchemas.rows || {};
             case 'column':
                 return this.targetSchemas.columns || {};
+            case 'visualBlock':
+                return this.targetSchemas.visualBlocks || {};
             default:
                 return {};
         }
@@ -10781,6 +10789,8 @@ class RuleDefinitionComponent {
                 return this.t('ruleDefinition.targetType.rowPlural', 'Linhas');
             case 'column':
                 return this.t('ruleDefinition.targetType.columnPlural', 'Colunas');
+            case 'visualBlock':
+                return this.t('ruleDefinition.targetType.visualBlockPlural', 'Blocos visuais');
             default:
                 return this.t('ruleDefinition.targetType.fieldPlural', 'Campos');
         }
@@ -12657,6 +12667,9 @@ class RuleEditorComponent {
             return;
         }
         const finalResponse = validation.correctedResponse || aiResponse;
+        const finalCondition = finalResponse.condition
+            ? finalResponse.condition
+            : undefined;
         try {
             const draftNodeId = this.ruleBuilderService.addNode({
                 type: RuleNodeType.PROPERTY_RULE,
@@ -12665,7 +12678,7 @@ class RuleEditorComponent {
                     type: 'propertyRule',
                     targetType: finalResponse.targetType,
                     targets: finalResponse.targetIds,
-                    condition: finalResponse.condition || undefined,
+                    condition: finalCondition,
                     properties: finalResponse.effects.properties,
                     propertiesWhenFalse: finalResponse.effects.propertiesWhenFalse,
                 },
@@ -13320,6 +13333,403 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImpo
                 type: Output
             }] } });
 
+const nodeAddSchema = {
+    type: 'object',
+    required: ['nodeId', 'nodeType'],
+    properties: {
+        nodeId: { type: 'string' },
+        nodeType: {
+            enum: [
+                'fieldCondition',
+                'propertyRule',
+                'andGroup',
+                'orGroup',
+                'notGroup',
+                'xorGroup',
+                'impliesGroup',
+                'requiredIf',
+                'visibleIf',
+                'disabledIf',
+                'readonlyIf',
+                'forEach',
+                'uniqueBy',
+                'minLength',
+                'maxLength',
+                'ifDefined',
+                'ifNotNull',
+                'ifExists',
+                'withDefault',
+                'functionCall',
+                'fieldToField',
+                'contextual',
+                'atLeast',
+                'exactly',
+                'expression',
+                'contextualTemplate',
+                'custom',
+            ],
+        },
+        label: { type: 'string' },
+        parentId: { type: 'string' },
+        config: { type: 'object' },
+        metadata: { type: 'object' },
+    },
+};
+const nodeRemoveSchema = {
+    type: 'object',
+    required: ['nodeId'],
+    properties: {
+        nodeId: { type: 'string' },
+        removeDescendants: { type: 'boolean' },
+        preserveDisconnectedChildren: { type: 'boolean' },
+    },
+};
+const nodeConfigureSchema = {
+    type: 'object',
+    required: ['nodeId'],
+    properties: {
+        nodeId: { type: 'string' },
+        label: { type: 'string' },
+        configPatch: { type: 'object' },
+        metadataPatch: { type: 'object' },
+        expanded: { type: 'boolean' },
+    },
+};
+const edgeConnectSchema = {
+    type: 'object',
+    required: ['sourceNodeId', 'targetNodeId'],
+    properties: {
+        sourceNodeId: { type: 'string' },
+        targetNodeId: { type: 'string' },
+        edgeKind: { enum: ['child', 'condition', 'effect'] },
+        insertIndex: { type: 'number' },
+    },
+};
+const edgeRemoveSchema = {
+    type: 'object',
+    required: ['sourceNodeId', 'targetNodeId'],
+    properties: {
+        sourceNodeId: { type: 'string' },
+        targetNodeId: { type: 'string' },
+        edgeKind: { enum: ['child', 'condition', 'effect'] },
+        removeOrphanTarget: { type: 'boolean' },
+    },
+};
+const variableAddSchema = {
+    type: 'object',
+    required: ['name', 'scope', 'type'],
+    properties: {
+        name: { type: 'string' },
+        scope: { type: 'string' },
+        type: { enum: ['string', 'number', 'boolean', 'object', 'array'] },
+        valueType: { enum: ['literal', 'field', 'context', 'function'] },
+        defaultValue: {},
+        description: { type: 'string' },
+    },
+};
+const conditionSetSchema = {
+    type: 'object',
+    required: ['nodeId', 'condition'],
+    properties: {
+        nodeId: { type: 'string' },
+        condition: { type: 'object' },
+        mode: { enum: ['replace', 'merge'] },
+        source: { enum: ['visual', 'jsonLogic'] },
+    },
+};
+const effectSetSchema = {
+    type: 'object',
+    required: ['nodeId', 'targetType', 'targets', 'properties'],
+    properties: {
+        nodeId: { type: 'string' },
+        targetType: { enum: ['field', 'section', 'action', 'row', 'column', 'visualBlock'] },
+        targets: {
+            type: 'array',
+            items: { type: 'string' },
+        },
+        properties: { type: 'object' },
+        propertiesWhenFalse: { type: 'object' },
+        conditionNodeId: { type: 'string' },
+    },
+};
+const dslRoundTripValidateSchema = {
+    type: 'object',
+    properties: {
+        format: { enum: ['json'] },
+        requireStableIds: { type: 'boolean' },
+        compareMode: { enum: ['semantic', 'exact'] },
+    },
+};
+const PRAXIS_VISUAL_BUILDER_AUTHORING_MANIFEST = {
+    schemaVersion: '1.0.0',
+    componentId: 'praxis-visual-builder',
+    ownerPackage: '@praxisui/visual-builder',
+    configSchemaId: 'RuleBuilderState',
+    manifestVersion: '1.0.0',
+    runtimeInputs: [
+        { name: 'config', type: 'RuleBuilderConfig | null', description: 'Builder configuration with field schemas, target schemas, context variables, validation and export/import settings.' },
+        { name: 'initialRules', type: 'RuleBuilderState | FormLayoutRule[] | JsonLogicExpression | null', description: 'Initial rules loaded into the visual builder.' },
+        { name: 'rulesChanged', type: 'RuleBuilderState', description: 'Emitted visual builder state after graph or JSON Logic changes.' },
+        { name: 'exportRequested', type: 'ExportOptions', description: 'Emitted export request for JSON, TypeScript or form-config payloads.' },
+        { name: 'importRequested', type: 'ImportOptions', description: 'Emitted import request for JSON or form-config payloads.' },
+    ],
+    editableTargets: [
+        { kind: 'node', resolver: 'rule-node-by-id', description: 'Visual rule graph node keyed by stable RuleNode.id.' },
+        { kind: 'edge', resolver: 'rule-node-edge-by-source-target', description: 'Parent-child or semantic graph edge between existing rule nodes.' },
+        { kind: 'variable', resolver: 'context-variable-by-name-scope', description: 'Context variable available to rule conditions and contextual nodes.' },
+        { kind: 'condition', resolver: 'json-logic-condition-by-node', description: 'JSON Logic condition attached to a node or represented by condition nodes.' },
+        { kind: 'effect', resolver: 'property-effect-by-node', description: 'Targeted property effect persisted as propertyRule/FormLayoutRule semantics.' },
+        { kind: 'dslDocument', resolver: 'rule-builder-json-logic-document', description: 'Serialized JSON Logic/form-config document produced from the visual model.' },
+    ],
+    operations: [
+        {
+            operationId: 'node.add',
+            title: 'Add visual rule node',
+            scope: 'rules',
+            targetKind: 'node',
+            target: { kind: 'node', resolver: 'rule-node-by-id', ambiguityPolicy: 'fail', required: true },
+            inputSchema: nodeAddSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'visual-builder-node-add', handlerContract: {
+                        reads: ['RuleBuilderState.nodes', 'RuleBuilderState.rootNodes', 'RuleNodeRegistryService', 'RuleBuilderService.addNode'],
+                        writes: ['RuleBuilderState.nodes', 'RuleBuilderState.rootNodes', 'RuleNodeRegistryService'],
+                        identityKeys: ['nodeId'],
+                        inputSchema: nodeAddSchema,
+                        failureModes: ['duplicate-node-id', 'unsupported-node-type', 'parent-node-not-found', 'graph-cycle-created'],
+                        description: 'Adds a rule node by stable id and validates graph integrity before the state can be serialized.',
+                    } }],
+            validators: ['node-id-unique', 'node-type-supported', 'parent-node-exists', 'graph-valid', 'dsl-round-trip-stable'],
+            affectedPaths: ['RuleBuilderState.nodes', 'RuleBuilderState.rootNodes', 'RuleNodeRegistryService'],
+            submissionImpact: 'config-only',
+            preconditions: ['rule-builder-state-loaded'],
+            destructive: false,
+            requiresConfirmation: false,
+        },
+        {
+            operationId: 'node.remove',
+            title: 'Remove visual rule node',
+            scope: 'rules',
+            targetKind: 'node',
+            target: { kind: 'node', resolver: 'rule-node-by-id', ambiguityPolicy: 'fail', required: true },
+            inputSchema: nodeRemoveSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'visual-builder-node-remove', handlerContract: {
+                        reads: ['RuleBuilderState.nodes', 'RuleBuilderState.rootNodes', 'RuleNodeRegistryService', 'RuleBuilderService.removeNode'],
+                        writes: ['RuleBuilderState.nodes', 'RuleBuilderState.rootNodes', 'RuleNodeRegistryService'],
+                        identityKeys: ['nodeId'],
+                        inputSchema: nodeRemoveSchema,
+                        failureModes: ['node-not-found', 'destructive-removal-not-confirmed', 'orphaned-edge-created', 'dsl-round-trip-failed'],
+                        description: 'Removes a node and governed descendants by id, requiring confirmation because conditions/effects can be lost.',
+                    } }],
+            destructive: true,
+            requiresConfirmation: true,
+            validators: ['node-exists', 'destructive-removal-confirmed', 'edges-reference-existing-nodes', 'dsl-round-trip-stable'],
+            affectedPaths: ['RuleBuilderState.nodes', 'RuleBuilderState.rootNodes', 'RuleNodeRegistryService'],
+            submissionImpact: 'config-only',
+            preconditions: ['rule-builder-state-loaded', 'explicit-confirmation-provided'],
+        },
+        {
+            operationId: 'node.configure',
+            title: 'Configure visual rule node',
+            scope: 'rules',
+            targetKind: 'node',
+            target: { kind: 'node', resolver: 'rule-node-by-id', ambiguityPolicy: 'fail', required: true },
+            inputSchema: nodeConfigureSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'visual-builder-node-configure', handlerContract: {
+                        reads: ['RuleBuilderState.nodes', 'RuleBuilderService.updateNode', 'RuleNodeRegistryService'],
+                        writes: ['RuleBuilderState.nodes', 'RuleBuilderState.currentJSON'],
+                        identityKeys: ['nodeId'],
+                        inputSchema: nodeConfigureSchema,
+                        failureModes: ['node-not-found', 'config-shape-invalid', 'node-type-config-mismatch', 'dsl-round-trip-failed'],
+                        description: 'Applies a typed patch to a rule node while preserving node identity and JSON Logic serialization.',
+                    } }],
+            validators: ['node-exists', 'node-config-compatible', 'graph-valid', 'dsl-round-trip-stable'],
+            affectedPaths: ['RuleBuilderState.nodes', 'RuleBuilderState.currentJSON'],
+            submissionImpact: 'config-only',
+            preconditions: ['rule-builder-state-loaded'],
+            destructive: false,
+            requiresConfirmation: false,
+        },
+        {
+            operationId: 'edge.connect',
+            title: 'Connect visual graph edge',
+            scope: 'interaction',
+            targetKind: 'edge',
+            target: { kind: 'edge', resolver: 'rule-node-edge-by-source-target', ambiguityPolicy: 'fail', required: true },
+            inputSchema: edgeConnectSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'visual-builder-edge-connect', handlerContract: {
+                        reads: ['RuleBuilderState.nodes', 'RuleNodeRegistryService.validateIntegrity'],
+                        writes: ['RuleBuilderState.nodes[].children', 'RuleBuilderState.nodes[].parentId'],
+                        identityKeys: ['sourceNodeId', 'targetNodeId', 'edgeKind'],
+                        inputSchema: edgeConnectSchema,
+                        failureModes: ['source-node-not-found', 'target-node-not-found', 'duplicate-edge', 'graph-cycle-created'],
+                        description: 'Connects two existing nodes and rejects edges that break registry integrity or acyclic graph requirements.',
+                    } }],
+            validators: ['node-exists', 'edges-reference-existing-nodes', 'graph-acyclic-where-required', 'dsl-round-trip-stable'],
+            affectedPaths: ['RuleBuilderState.nodes[].children', 'RuleBuilderState.nodes[].parentId'],
+            submissionImpact: 'config-only',
+            preconditions: ['rule-builder-state-loaded'],
+            destructive: false,
+            requiresConfirmation: false,
+        },
+        {
+            operationId: 'edge.remove',
+            title: 'Remove visual graph edge',
+            scope: 'interaction',
+            targetKind: 'edge',
+            target: { kind: 'edge', resolver: 'rule-node-edge-by-source-target', ambiguityPolicy: 'fail', required: true },
+            inputSchema: edgeRemoveSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'visual-builder-edge-remove', handlerContract: {
+                        reads: ['RuleBuilderState.nodes', 'RuleNodeRegistryService.validateIntegrity'],
+                        writes: ['RuleBuilderState.nodes[].children', 'RuleBuilderState.nodes[].parentId'],
+                        identityKeys: ['sourceNodeId', 'targetNodeId', 'edgeKind'],
+                        inputSchema: edgeRemoveSchema,
+                        failureModes: ['edge-not-found', 'destructive-removal-not-confirmed', 'orphaned-node-created', 'dsl-round-trip-failed'],
+                        description: 'Removes a graph edge by source and target ids with confirmation when the target can become orphaned.',
+                    } }],
+            destructive: true,
+            requiresConfirmation: true,
+            validators: ['edge-exists', 'destructive-removal-confirmed', 'graph-valid', 'dsl-round-trip-stable'],
+            affectedPaths: ['RuleBuilderState.nodes[].children', 'RuleBuilderState.nodes[].parentId'],
+            submissionImpact: 'config-only',
+            preconditions: ['rule-builder-state-loaded', 'explicit-confirmation-provided'],
+        },
+        {
+            operationId: 'variable.add',
+            title: 'Add context variable',
+            scope: 'dataBinding',
+            targetKind: 'variable',
+            target: { kind: 'variable', resolver: 'context-variable-by-name-scope', ambiguityPolicy: 'fail', required: true },
+            inputSchema: variableAddSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'visual-builder-variable-add', handlerContract: {
+                        reads: ['RuleBuilderConfig.contextVariables', 'ContextManagementService'],
+                        writes: ['RuleBuilderConfig.contextVariables', 'ContextManagementService'],
+                        identityKeys: ['scope', 'name'],
+                        inputSchema: variableAddSchema,
+                        failureModes: ['duplicate-variable', 'scope-not-found', 'variable-type-invalid', 'context-token-conflict'],
+                        description: 'Adds a governed context variable that can be referenced by contextual and field condition nodes.',
+                    } }],
+            validators: ['variable-id-unique', 'variable-scope-exists', 'context-variable-reference-valid', 'dsl-round-trip-stable'],
+            affectedPaths: ['RuleBuilderConfig.contextVariables', 'ContextManagementService'],
+            submissionImpact: 'config-only',
+            preconditions: ['rule-builder-config-loaded'],
+            destructive: false,
+            requiresConfirmation: false,
+        },
+        {
+            operationId: 'condition.set',
+            title: 'Set JSON Logic condition',
+            scope: 'rules',
+            targetKind: 'condition',
+            target: { kind: 'condition', resolver: 'json-logic-condition-by-node', ambiguityPolicy: 'fail', required: true },
+            inputSchema: conditionSetSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'visual-builder-condition-set', handlerContract: {
+                        reads: ['RuleBuilderState.nodes', 'RuleBuilderService.loadFromConditionExpression', 'RuleBuilderService.buildConditionExpressionFromGraph'],
+                        writes: ['RuleBuilderState.nodes[].config.condition', 'RuleBuilderState.currentJSON'],
+                        identityKeys: ['nodeId'],
+                        inputSchema: conditionSetSchema,
+                        failureModes: ['node-not-found', 'json-logic-invalid', 'unsupported-operator', 'visual-parse-failed', 'dsl-round-trip-failed'],
+                        description: 'Sets a canonical JSON Logic condition and proves it can parse back into the visual graph.',
+                    } }],
+            validators: ['json-logic-valid', 'condition-operators-supported', 'condition-fields-known', 'dsl-round-trip-stable'],
+            affectedPaths: ['RuleBuilderState.nodes[].config.condition', 'RuleBuilderState.currentJSON'],
+            submissionImpact: 'config-only',
+            preconditions: ['rule-builder-state-loaded'],
+            destructive: false,
+            requiresConfirmation: false,
+        },
+        {
+            operationId: 'effect.set',
+            title: 'Set visual property effect',
+            scope: 'rules',
+            targetKind: 'effect',
+            target: { kind: 'effect', resolver: 'property-effect-by-node', ambiguityPolicy: 'fail', required: true },
+            inputSchema: effectSetSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'visual-builder-effect-set', handlerContract: {
+                        reads: ['RuleBuilderState.nodes', 'RuleBuilderConfig.targetPropertySchemas', 'RULE_PROPERTY_SCHEMA', 'RuleBuilderService.export'],
+                        writes: ['RuleBuilderState.nodes[].config.targetType', 'RuleBuilderState.nodes[].config.targets', 'RuleBuilderState.nodes[].config.properties', 'RuleBuilderState.nodes[].config.propertiesWhenFalse', 'RuleBuilderState.currentJSON'],
+                        identityKeys: ['nodeId', 'targetType', 'targets'],
+                        inputSchema: effectSetSchema,
+                        failureModes: ['node-not-found', 'target-not-found', 'property-not-allowed-for-target', 'effect-value-invalid', 'dsl-round-trip-failed'],
+                        description: 'Sets a property effect using governed target property schemas so export to FormLayoutRule remains deterministic.',
+                    } }],
+            validators: ['effect-targets-exist', 'effect-properties-governed', 'effect-values-valid', 'dsl-round-trip-stable'],
+            affectedPaths: ['RuleBuilderState.nodes[].config.targetType', 'RuleBuilderState.nodes[].config.targets', 'RuleBuilderState.nodes[].config.properties', 'RuleBuilderState.nodes[].config.propertiesWhenFalse', 'RuleBuilderState.currentJSON'],
+            submissionImpact: 'affects-schema-backed-data',
+            preconditions: ['rule-builder-state-loaded', 'target-schema-loaded'],
+            destructive: false,
+            requiresConfirmation: false,
+        },
+        {
+            operationId: 'dsl.roundTrip.validate',
+            title: 'Validate visual and DSL round trip',
+            scope: 'runtimeCoverage',
+            targetKind: 'dslDocument',
+            target: { kind: 'dslDocument', resolver: 'rule-builder-json-logic-document', ambiguityPolicy: 'fail', required: false },
+            inputSchema: dslRoundTripValidateSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'visual-builder-dsl-round-trip-validate', handlerContract: {
+                        reads: ['RuleBuilderState', 'RuleBuilderService.export', 'RuleBuilderService.import', 'RuleBuilderService.buildConditionExpressionFromGraph', 'RuleNodeRegistryService.validateIntegrity'],
+                        writes: ['RuleBuilderState.validationErrors', 'RuleBuilderState.currentJSON'],
+                        identityKeys: ['format', 'compareMode'],
+                        inputSchema: dslRoundTripValidateSchema,
+                        failureModes: ['graph-invalid', 'export-failed', 'import-failed', 'semantic-drift', 'unstable-node-identity'],
+                        description: 'Exports the visual model to JSON, imports it back and rejects semantic drift or unstable identity.',
+                    } }],
+            validators: ['graph-valid', 'dsl-round-trip-stable', 'json-logic-valid', 'registry-integrity-valid'],
+            affectedPaths: ['RuleBuilderState.currentJSON', 'RuleBuilderState.validationErrors'],
+            submissionImpact: 'none',
+            preconditions: ['rule-builder-state-loaded'],
+            destructive: false,
+            requiresConfirmation: false,
+        },
+    ],
+    validators: [
+        { validatorId: 'node-id-unique', level: 'error', code: 'VISUAL_BUILDER_NODE_ID_UNIQUE', description: 'Rule node ids must be unique and stable.' },
+        { validatorId: 'node-exists', level: 'error', code: 'VISUAL_BUILDER_NODE_EXISTS', description: 'Target node must exist before it is configured or removed.' },
+        { validatorId: 'node-type-supported', level: 'error', code: 'VISUAL_BUILDER_NODE_TYPE_SUPPORTED', description: 'Node type must be supported by the rule node registry and visual editor.' },
+        { validatorId: 'node-config-compatible', level: 'error', code: 'VISUAL_BUILDER_NODE_CONFIG_COMPATIBLE', description: 'Node config must match the declared node type.' },
+        { validatorId: 'parent-node-exists', level: 'error', code: 'VISUAL_BUILDER_PARENT_NODE_EXISTS', description: 'Parent node must exist when adding a child node.' },
+        { validatorId: 'edge-exists', level: 'error', code: 'VISUAL_BUILDER_EDGE_EXISTS', description: 'Target edge must exist before removal.' },
+        { validatorId: 'edges-reference-existing-nodes', level: 'error', code: 'VISUAL_BUILDER_EDGES_REFERENCE_NODES', description: 'Every edge must reference existing source and target nodes.' },
+        { validatorId: 'graph-valid', level: 'error', code: 'VISUAL_BUILDER_GRAPH_VALID', description: 'Graph structure must pass registry integrity validation.' },
+        { validatorId: 'graph-acyclic-where-required', level: 'error', code: 'VISUAL_BUILDER_GRAPH_ACYCLIC', description: 'Hierarchical rule graph edges must not introduce cycles.' },
+        { validatorId: 'destructive-removal-confirmed', level: 'error', code: 'VISUAL_BUILDER_DESTRUCTIVE_REMOVAL_CONFIRMED', description: 'Destructive node or edge removal requires explicit confirmation.' },
+        { validatorId: 'variable-id-unique', level: 'error', code: 'VISUAL_BUILDER_VARIABLE_ID_UNIQUE', description: 'Context variable name and scope must be unique.' },
+        { validatorId: 'variable-scope-exists', level: 'error', code: 'VISUAL_BUILDER_VARIABLE_SCOPE_EXISTS', description: 'Context variable scope must exist in ContextManagementService before variables are added.' },
+        { validatorId: 'context-variable-reference-valid', level: 'error', code: 'VISUAL_BUILDER_CONTEXT_VARIABLE_VALID', description: 'Context variable references must resolve to declared variables.' },
+        { validatorId: 'json-logic-valid', level: 'error', code: 'VISUAL_BUILDER_JSON_LOGIC_VALID', description: 'Conditions must be valid JSON Logic objects, not JavaScript or legacy textual DSL.' },
+        { validatorId: 'condition-operators-supported', level: 'error', code: 'VISUAL_BUILDER_CONDITION_OPERATORS_SUPPORTED', description: 'Condition operators must be supported by visual parsing and export.' },
+        { validatorId: 'condition-fields-known', level: 'error', code: 'VISUAL_BUILDER_CONDITION_FIELDS_KNOWN', description: 'Condition field references must resolve to configured field schemas or context variables.' },
+        { validatorId: 'effect-targets-exist', level: 'error', code: 'VISUAL_BUILDER_EFFECT_TARGETS_EXIST', description: 'Effect targets must exist in configured target schemas.' },
+        { validatorId: 'effect-properties-governed', level: 'error', code: 'VISUAL_BUILDER_EFFECT_PROPERTIES_GOVERNED', description: 'Effect properties must be allowed for the target type.' },
+        { validatorId: 'effect-values-valid', level: 'error', code: 'VISUAL_BUILDER_EFFECT_VALUES_VALID', description: 'Effect property values must satisfy target property schema types.' },
+        { validatorId: 'registry-integrity-valid', level: 'error', code: 'VISUAL_BUILDER_REGISTRY_INTEGRITY_VALID', description: 'RuleNodeRegistryService integrity checks must pass.' },
+        { validatorId: 'dsl-round-trip-stable', level: 'error', code: 'VISUAL_BUILDER_DSL_ROUND_TRIP_STABLE', description: 'Serialized JSON output must import back to the same semantic visual model.' },
+    ],
+    roundTripRequirements: [
+        'RuleBuilderState is the visual source of truth; JSON export must import back without semantic drift.',
+        'RuleNode.id and context variable scope/name are canonical identities; array indexes are not canonical identities.',
+        'Edges must reference existing nodes and must not create cycles in hierarchical rule graphs.',
+        'Conditions are canonical JSON Logic objects. JavaScript expressions and legacy textual DSL must not be introduced as persisted authoring payloads.',
+        'Effects must be constrained by target property schemas and RULE_PROPERTY_SCHEMA so exported FormLayoutRule payloads stay deterministic.',
+        'Component-specific configuration belongs to child component manifests; visual-builder owns graph, JSON Logic, variables and property-effect orchestration.',
+    ],
+    examples: [
+        { id: 'add-field-condition', request: 'Add a condition that age is greater than 18.', operationId: 'node.add', params: { nodeId: 'age-gt-18', nodeType: 'fieldCondition', label: 'Age over 18', config: { type: 'fieldCondition', fieldName: 'age', operator: 'gt', value: 18 } }, isPositive: true },
+        { id: 'add-property-rule', request: 'Add a rule that hides the spouse section.', operationId: 'node.add', params: { nodeId: 'hide-spouse-section', nodeType: 'propertyRule', config: { type: 'propertyRule', targetType: 'section', targets: ['spouse'], properties: { visible: false } } }, isPositive: true },
+        { id: 'configure-node', request: 'Rename the eligibility rule and mark it expanded.', operationId: 'node.configure', params: { nodeId: 'eligibility', label: 'Eligibility rule', expanded: true }, isPositive: true },
+        { id: 'connect-edge', request: 'Make the age condition a child of the AND group.', operationId: 'edge.connect', params: { sourceNodeId: 'eligibility-and', targetNodeId: 'age-gt-18', edgeKind: 'child' }, isPositive: true },
+        { id: 'remove-edge', request: 'Disconnect the age condition from the AND group.', operationId: 'edge.remove', params: { sourceNodeId: 'eligibility-and', targetNodeId: 'age-gt-18', edgeKind: 'child' }, isPositive: true },
+        { id: 'add-variable', request: 'Add a global variable for current tenant.', operationId: 'variable.add', params: { name: 'tenantId', scope: 'global', type: 'string', valueType: 'context', description: 'Current tenant id' }, isPositive: true },
+        { id: 'set-condition', request: 'Set this condition to require country equal Brazil.', operationId: 'condition.set', params: { nodeId: 'country-br', condition: { '===': [{ var: 'country' }, 'BR'] }, source: 'jsonLogic' }, isPositive: true },
+        { id: 'set-effect', request: 'Make the salary field readonly when the condition is true.', operationId: 'effect.set', params: { nodeId: 'salary-readonly', targetType: 'field', targets: ['salary'], properties: { readonly: true } }, isPositive: true },
+        { id: 'validate-round-trip', request: 'Validate that this graph exports and imports without drift.', operationId: 'dsl.roundTrip.validate', params: { format: 'json', requireStableIds: true, compareMode: 'semantic' }, isPositive: true },
+        { id: 'reject-duplicate-node', request: 'Add another node with id age-gt-18.', operationId: 'node.add', params: { nodeId: 'age-gt-18', nodeType: 'fieldCondition' }, isPositive: false },
+        { id: 'reject-cycle', request: 'Connect a child back to its parent and create a cycle.', operationId: 'edge.connect', params: { sourceNodeId: 'age-gt-18', targetNodeId: 'eligibility-and', edgeKind: 'child' }, isPositive: false },
+        { id: 'reject-javascript-condition', request: 'Use age > 18 as a JavaScript expression.', operationId: 'condition.set', params: { nodeId: 'age-gt-18', condition: 'age > 18' }, isPositive: false },
+        { id: 'reject-unknown-effect-property', request: 'Set an unknown field property named sparkle.', operationId: 'effect.set', params: { nodeId: 'sparkle-field', targetType: 'field', targets: ['name'], properties: { sparkle: true } }, isPositive: false },
+        { id: 'reject-drift', request: 'Accept the graph even though export/import changes node meaning.', operationId: 'dsl.roundTrip.validate', params: { format: 'json', compareMode: 'exact' }, isPositive: false },
+    ],
+};
+
 /**
  * Array Field Schema Support for Collection Validators
  * Phase 2 Implementation
@@ -20427,4 +20837,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImpo
  * Generated bundle index. Do not edit.
  */
 
-export { ArrayFieldAnalyzer, CollectionValidatorEditorComponent, ConditionalValidatorEditorComponent, ConditionalValidatorType, ConfigurationError, ContextError, ContextManagementService, ConversionError, ErrorCategory, ErrorHandler, ErrorSeverity, ExportDialogComponent, ExportIntegrationService, ExpressionError, FIELD_TYPE_OPERATORS, FieldConditionEditorComponent, FieldSchemaService, FieldType, InternalError, JsonViewerComponent, MetadataEditorComponent, OPERATOR_LABELS, PraxisVisualBuilder, RegistryError, RuleBuilderService, RuleCanvasComponent, RuleEditorComponent, RuleListComponent, RuleNodeComponent, RuleNodeRegistryService, RuleNodeType, RuleTemplateService, RuleValidationService, TemplateEditorDialogComponent, TemplateGalleryComponent, TemplatePreviewDialogComponent, ValidationError as VBValidationError, ValidationCategory, ValidationSeverity, VisualBuilderError, VisualRuleBuilderComponent, WebhookIntegrationService, createError, getArrayItemFieldPaths, globalErrorHandler, isArrayFieldSchema };
+export { ArrayFieldAnalyzer, CollectionValidatorEditorComponent, ConditionalValidatorEditorComponent, ConditionalValidatorType, ConfigurationError, ContextError, ContextManagementService, ConversionError, ErrorCategory, ErrorHandler, ErrorSeverity, ExportDialogComponent, ExportIntegrationService, ExpressionError, FIELD_TYPE_OPERATORS, FieldConditionEditorComponent, FieldSchemaService, FieldType, InternalError, JsonViewerComponent, MetadataEditorComponent, OPERATOR_LABELS, PRAXIS_VISUAL_BUILDER_AUTHORING_MANIFEST, PraxisVisualBuilder, RegistryError, RuleBuilderService, RuleCanvasComponent, RuleEditorComponent, RuleListComponent, RuleNodeComponent, RuleNodeRegistryService, RuleNodeType, RuleTemplateService, RuleValidationService, TemplateEditorDialogComponent, TemplateGalleryComponent, TemplatePreviewDialogComponent, ValidationError as VBValidationError, ValidationCategory, ValidationSeverity, VisualBuilderError, VisualRuleBuilderComponent, WebhookIntegrationService, createError, getArrayItemFieldPaths, globalErrorHandler, isArrayFieldSchema };

package/index.d.ts

@@ -1,6 +1,6 @@
 import * as i0 from '@angular/core';
 import { EventEmitter, OnInit, OnDestroy, OnChanges, AfterViewInit, ElementRef, ChangeDetectorRef, SimpleChanges } from '@angular/core';
-import { JsonLogicExpression, FormLayoutRule, RulePropertySchema, PraxisI18nService } from '@praxisui/core';
+import { JsonLogicExpression, ComponentAuthoringManifest, FormLayoutRule, RulePropertySchema, PraxisI18nService } from '@praxisui/core';
 import { Observable } from 'rxjs';
 import { MatDialog, MatDialogRef } from '@angular/material/dialog';
 import { MatSnackBar } from '@angular/material/snack-bar';
@@ -121,7 +121,7 @@ interface FieldConditionConfig {
 }
 interface PropertyRuleConfig {
     type: 'propertyRule';
-    targetType: 'field' | 'section' | 'action' | 'row' | 'column';
+    targetType: 'field' | 'section' | 'action' | 'row' | 'column' | 'visualBlock';
     /** Target IDs without prefix (namespace is defined by targetType) */
     targets: string[];
     /** Properties applied when condition is true */
@@ -512,9 +512,10 @@ interface RuleBuilderConfig {
         actions?: Record<string, unknown>;
         rows?: Record<string, unknown>;
         columns?: Record<string, unknown>;
+        visualBlocks?: Record<string, unknown>;
     };
     /** Optional property schema per targetType for typed property editing */
-    targetPropertySchemas?: Record<'field' | 'section' | 'action' | 'row' | 'column', Array<{
+    targetPropertySchemas?: Record<'field' | 'section' | 'action' | 'row' | 'column' | 'visualBlock', Array<{
         name: string;
         type: 'string' | 'boolean' | 'object' | 'enum' | 'number';
         label?: string;
@@ -630,6 +631,8 @@ declare class PraxisVisualBuilder {
     static ɵcmp: i0.ɵɵComponentDeclaration<PraxisVisualBuilder, "praxis-visual-builder", never, { "config": { "alias": "config"; "required": false; }; "initialRules": { "alias": "initialRules"; "required": false; }; }, { "rulesChanged": "rulesChanged"; "exportRequested": "exportRequested"; "importRequested": "importRequested"; }, never, never, true, never>;
 }
 
+declare const PRAXIS_VISUAL_BUILDER_AUTHORING_MANIFEST: ComponentAuthoringManifest;
+
 /**
  * Field schema model for dynamic field configuration in the Visual Builder
  */
@@ -639,7 +642,7 @@ interface FieldSchema {
     /** Human-readable field label */
     label: string;
     /** Logical origin to help context-sensitive filtering (form field, section, row, column, table column, etc.) */
-    origin?: 'field' | 'section' | 'action' | 'row' | 'column' | 'tableField' | 'tableColumn';
+    origin?: 'field' | 'section' | 'action' | 'row' | 'column' | 'visualBlock' | 'tableField' | 'tableColumn';
     /** Field data type */
     type: FieldType | string;
     /** Optional description or help text */
@@ -2179,7 +2182,7 @@ declare const createError: {
     internal: (message: string, cause?: Error) => InternalError;
 };
 
-type TargetType = 'field' | 'section' | 'action' | 'row' | 'column';
+type TargetType = 'field' | 'section' | 'action' | 'row' | 'column' | 'visualBlock';
 type RuleNodeConfigExtended = RuleNodeConfig & {
     targetType?: TargetType;
     properties?: Record<string, any>;
@@ -2905,5 +2908,5 @@ declare class RuleListComponent {
     static ɵcmp: i0.ɵɵComponentDeclaration<RuleListComponent, "praxis-rule-list", never, { "rules": { "alias": "rules"; "required": false; }; "selectedRuleId": { "alias": "selectedRuleId"; "required": false; }; "nodeMap": { "alias": "nodeMap"; "required": false; }; "validationErrors": { "alias": "validationErrors"; "required": false; }; }, { "ruleSelected": "ruleSelected"; "ruleDeleted": "ruleDeleted"; "ruleDuplicated": "ruleDuplicated"; "ruleAdded": "ruleAdded"; "aiRequested": "aiRequested"; }, never, never, true, never>;
 }
 
-export { ArrayFieldAnalyzer, CollectionValidatorEditorComponent, ConditionalValidatorEditorComponent, ConditionalValidatorType, ConfigurationError, ContextError, ContextManagementService, ConversionError, ErrorCategory, ErrorHandler, ErrorSeverity, ExportDialogComponent, ExportIntegrationService, ExpressionError, FIELD_TYPE_OPERATORS, FieldConditionEditorComponent, FieldSchemaService, FieldType, InternalError, JsonViewerComponent, MetadataEditorComponent, OPERATOR_LABELS, PraxisVisualBuilder, RegistryError, RuleBuilderService, RuleCanvasComponent, RuleEditorComponent, RuleListComponent, RuleNodeComponent, RuleNodeRegistryService, RuleNodeType, RuleTemplateService, RuleValidationService, TemplateEditorDialogComponent, TemplateGalleryComponent, TemplatePreviewDialogComponent, ValidationError as VBValidationError, ValidationCategory, ValidationSeverity, VisualBuilderError, VisualRuleBuilderComponent, WebhookIntegrationService, createError, getArrayItemFieldPaths, globalErrorHandler, isArrayFieldSchema };
+export { ArrayFieldAnalyzer, CollectionValidatorEditorComponent, ConditionalValidatorEditorComponent, ConditionalValidatorType, ConfigurationError, ContextError, ContextManagementService, ConversionError, ErrorCategory, ErrorHandler, ErrorSeverity, ExportDialogComponent, ExportIntegrationService, ExpressionError, FIELD_TYPE_OPERATORS, FieldConditionEditorComponent, FieldSchemaService, FieldType, InternalError, JsonViewerComponent, MetadataEditorComponent, OPERATOR_LABELS, PRAXIS_VISUAL_BUILDER_AUTHORING_MANIFEST, PraxisVisualBuilder, RegistryError, RuleBuilderService, RuleCanvasComponent, RuleEditorComponent, RuleListComponent, RuleNodeComponent, RuleNodeRegistryService, RuleNodeType, RuleTemplateService, RuleValidationService, TemplateEditorDialogComponent, TemplateGalleryComponent, TemplatePreviewDialogComponent, ValidationError as VBValidationError, ValidationCategory, ValidationSeverity, VisualBuilderError, VisualRuleBuilderComponent, WebhookIntegrationService, createError, getArrayItemFieldPaths, globalErrorHandler, isArrayFieldSchema };
 export type { ArrayCollectionValidationRule, ArrayFieldSchema, ArrayValidationContext, ArrayValidationError, BooleanGroupConfig, CardinalityConfig, CircularReference, CleanupResult, CollectionValidationConfig, CollectionValidatorConfig, ConditionalValidatorConfig, ConditionalValidatorPreview, ContextEntry, ContextScope, ContextValue, ContextVariable, ContextualConfig, ContextualTemplateConfig, CustomConfig, CustomFunction, DocumentationLink, EnhancedFieldSchema, ErrorInfo, ErrorStatistics, ExportDialogData, ExportFormat, ExportOptions, ExportResult, ExpressionConfig, ExternalSystemConfig, FieldConditionConfig, FieldFormat, FieldOption, FieldSchema, FieldSchemaContext, FieldToFieldConfig, FieldUIConfig, FunctionCallConfig, FunctionParameter, ImportOptions, IntegrationEndpoint, IntegrationResult, MemoryStats, OptionalFieldConfig, PropertyRuleConfig, RegistryIntegrityResult, RegistryValidationResult, RuleBuilderConfig, RuleBuilderSnapshot, RuleBuilderState, RuleContextProvider, RuleFunctionRegistry, RuleNode, RuleNodeConfig, RuleNodeTree, RuleNodeTypeString, RuleTemplate, RuleValidationResult, SpecificationMetadata, TemplateApplicationResult, TemplateCategory, TemplateDisplayMode, TemplateEditorDialogData, TemplateEditorResult, TemplateMetadata, TemplatePreviewDialogData, TemplateSearchCriteria, TemplateSortOption, TemplateStats, TemplateValidationResult, ValidComparisonOperator, ValidationConfig, ValidationContext, ValidationError$1 as ValidationError, ValidationIssue, ValidationResult, ValidationRule, ValueType, WebhookConfig, WebhookDelivery, WebhookEvent, WebhookStats };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@praxisui/visual-builder",
-  "version": "8.0.0-beta.11",
+  "version": "8.0.0-beta.13",
   "description": "Visual rule and expression builder for Praxis UI with JSON Logic authoring, validation and context variables.",
   "peerDependencies": {
     "@angular/common": "^20.0.0",
@@ -8,7 +8,7 @@
     "@angular/cdk": "^20.0.0",
     "@angular/material": "^20.0.0",
     "@angular/forms": "^20.0.0",
-    "@praxisui/settings-panel": "^8.0.0-beta.11"
+    "@praxisui/settings-panel": "^8.0.0-beta.13"
   },
   "dependencies": {
     "tslib": "^2.3.0",