* @param resultData the result data to be processed
     * @return the access result containing the processed data
     */
    @Override
    protected AccessResult<?> createAccessResult(final ResponseData responseData, final ResultData resultData) {
        return super.createAccessResult(responseData, ingest(responseData, resultData));
    }

    /**
     * Processes the result data through all available ingesters.

        Object result1 = scriptExecutor.execute("testengine", "script1");
        assertEquals("processed: script1", result1);

        Object result2 = scriptExecutor.execute("TESTENGINE", "script2");
        assertEquals("processed: script2", result2);

        Object result3 = scriptExecutor.execute("TestEngine", "script3");
        assertEquals("processed: script3", result3);
    }

    public void test_execute_verifyParamsNotModifiable() {

        assertNotNull(queryBuilder);
        assertTrue(queryBuilder instanceof WildcardQueryBuilder);

        // Query was processed successfully

        // Query was processed successfully
        WildcardQueryBuilder wqb = (WildcardQueryBuilder) queryBuilder;
        assertEquals("title", wqb.fieldName());
    }

    }

    /**
     * Processes a document map for datastore operations.
     * Default implementation delegates to the basic process method.
     *
     * @param target the document data to process
     * @param params the data store parameters
     * @return the processed document data
     */
    public Map<String, Object> process(final Map<String, Object> target, final DataStoreParams params) {

     * @param query the Lucene query to be processed
     * @param boost the boost factor to apply to the query
     * @return the processed OpenSearch QueryBuilder
     */
    public QueryBuilder execute(final QueryContext context, final Query query, final float boost) {
        return filterChain.execute(context, query, boost);
    }

    /**
     * Adds a query command to the processor.
     *

     * Continuously processes crawled documents from the data service, transforms them,
     * and updates the search index until crawling is finished and all documents are processed.
     *
     * <p>The method performs the following operations in a loop:
     * <ul>
     * <li>Retrieves access results from the data service</li>
     * <li>Processes each document through transformers</li>

        QueryBuilder result = queryCommand.convertPhraseQuery(context, phraseQuery, 1.0f);

        assertNotNull(result);
        assertTrue(result instanceof DefaultQueryBuilder);

        // Verify query was processed
        // Note: Field logging behavior depends on implementation
    }

    public void test_convertPhraseQuery_singleTerm_defaultField_dismax() {
        // Test with single term in default field with boost > 1

            ComponentUtil.register(newQueryProcessor, "queryProcessor");

            // Register the command with the new processor
            PrefixQueryCommand newCommand = new PrefixQueryCommand();
            newCommand.register();

            // Verify that the command can process PrefixQuery by executing it
            PrefixQuery query = new PrefixQuery(new Term("field", "test"));

        }

    }

    /**
     * Processes a document through the ingest pipeline.
     * Applies all available ingesters to transform the document data.
     *
     * @param paramMap the data store parameters
     * @param dataMap the document data to process
     * @return the processed document data
     */

        assertEquals("processed: template with params", result);
    }

    // Test evaluate with empty parameters
    public void test_evaluate_emptyParams() {
        Map<String, Object> emptyParams = new HashMap<>();
        Object result = testScriptEngine.evaluate("template", emptyParams);
        assertEquals("processed: template with params", result);
    }