You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hugegraph.apache.org by ji...@apache.org on 2026/10/06 14:28:00 UTC

(hugegraph) 12/14: fix(server): close upgrade review gaps

This is an automated email from the ASF dual-hosted git repository.

imbajin pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/hugegraph.git

commit 5162b1ac856ce8b72524d4886b8a382cef913077
Author: imbajin <ji...@apache.org>
AuthorDate: Tue Oct 6 18:27:45 2026 +0800

    fix(server): close upgrade review gaps
    
    - remove unsafe typed GraphSON V1 from shipped configs
    - preserve mixed edge ID membership and count semantics
    - encode public enums and SchemaManager with standard wire values
    - share compatible Cypher factories across imports and replay
    - align Jackson modules and release dependency notices
---
 docs/upgrade-tinkerpop-3.8.md                      |  24 ++-
 hugegraph-commons/hugegraph-common/pom.xml         |   6 -
 hugegraph-commons/pom.xml                          |   1 -
 hugegraph-pd/hg-pd-cli/pom.xml                     |   7 -
 hugegraph-pd/hg-pd-test/pom.xml                    |   3 -
 .../opencypher/CypherGremlinPredicates.java        |  22 ++-
 .../apache/hugegraph/opencypher/CypherPlugin.java  |   8 +-
 hugegraph-server/hugegraph-core/pom.xml            |   3 -
 .../io/HugeGraphTypeSerializerRegistryBuilder.java |  34 ++++-
 .../traversal/optimize/TraversalUtil.java          |   9 +-
 .../src/assembly/static/conf/gremlin-server.yaml   |  14 +-
 .../src/assembly/static/conf/remote-objects.yaml   |   8 +-
 .../assembly/travis/conf-raft1/gremlin-server.yaml |  12 +-
 .../assembly/travis/conf-raft2/gremlin-server.yaml |  12 +-
 .../assembly/travis/conf-raft3/gremlin-server.yaml |  12 +-
 .../apache/hugegraph/core/IdPredicateCoreTest.java |  33 +++++
 .../org/apache/hugegraph/unit/UnitTestSuite.java   |   2 +
 .../config/GraphBinarySchemaCompatibilityTest.java | 165 +++++++++++++++++++++
 .../config/GremlinConfigCompatibilityTest.java     |  95 ++++++++----
 .../unit/config/K8sResourceQuotaYamlTest.java      |   4 +-
 .../opencypher/CypherGremlinPredicatesTest.java    |  59 ++++++++
 hugegraph-store/hg-store-client/pom.xml            |   1 -
 hugegraph-store/hg-store-test/pom.xml              |   3 -
 install-dist/release-docs/LICENSE                  |   3 +
 install-dist/release-docs/NOTICE                   |  69 +++++++++
 .../LICENSE-jackson-datatype-jdk8-2.15.2.txt       |   8 +
 ...CENSE-jackson-module-parameter-names-2.15.2.txt |   8 +
 .../scripts/dependency/known-dependencies.txt      |   3 +
 pom.xml                                            |  15 +-
 29 files changed, 534 insertions(+), 109 deletions(-)

diff --git a/docs/upgrade-tinkerpop-3.8.md b/docs/upgrade-tinkerpop-3.8.md
index 847b3ec3b..ce13a0ab9 100644
--- a/docs/upgrade-tinkerpop-3.8.md
+++ b/docs/upgrade-tinkerpop-3.8.md
@@ -32,8 +32,7 @@ serializer:
 
 GraphBinary preserves graph elements and UUID IDs for Java Driver accessors such
 as `Result.getVertex()` and `Result.get(UUID.class)`. Untyped GraphSON V1 decodes
-these results as maps and strings, and typed GraphSON V1 still decodes graph
-elements as maps.
+these results as maps and strings.
 
 `remote-objects.yaml` serves the Cypher HTTP JSON path and continues to use
 `org.apache.tinkerpop.gremlin.util.ser.GraphSONUntypedMessageSerializerV1` with
@@ -41,7 +40,7 @@ elements as maps.
 driver compatibility workaround.
 
 For the server, keep the GraphBinary builder and registry. The serializer order
-is GraphBinary, untyped GraphSON V1/V2/V3, then typed GraphSON V1/V2/V3. The
+is GraphBinary, untyped GraphSON V1/V2/V3, then typed GraphSON V2/V3. The
 GraphSON entries keep the HugeGraph registry. The first entries look like this:
 
 ```yaml
@@ -63,7 +62,8 @@ The full ordering is in `gremlin-server.yaml`; the config test checks that
 
 Typed GraphSON is available for the supported simple values and IDs, not as a
 replacement for untyped serialization of every HugeGraph schema or graph
-object. GraphSON V1 uses legacy `@class` metadata; V2/V3 use `@type`/`@value`.
+object. Typed V1 is not registered: its legacy `@class` deserialization can
+construct Java objects before request authentication. V2/V3 use `@type`/`@value`.
 
 GraphBinary uses `HugeGraphTypeSerializerRegistryBuilder` to write HugeGraph IDs
 as their underlying values. Schema results use standard maps and Blob values use
@@ -78,6 +78,15 @@ registry limited to untyped V1 messages. Standard graph-file IO and typed
 GraphSON serializers keep `HugeGraphIoRegistry` alone and use the TinkerPop
 Tree format for their negotiated version.
 
+HugeGraph enums such as `DataType.TEXT` and `Directions.OUT` return their names
+over GraphBinary, including in maps and lists. `graph.schema()` returns a map
+with `propertykeys`, `vertexlabels`, `edgelabels` and `indexlabels` lists, using
+the same schema conversion. TinkerPop enums retain their native wire types.
+
+Local edge ID filters accept both serialized strings and native edge IDs in
+mixed collections: `hasId(not(without(ids)))` and `hasId(within(ids))` agree on
+membership and count. Numeric and string vertex IDs keep their distinct types.
+
 Groovy interpolated strings (`GString`, including subclasses) return as standard
 strings over GraphBinary, including inside lists and maps. For example,
 `def value = 42; "r3-value:${value}"` returns `"r3-value:42"`. The untyped GraphSON
@@ -87,6 +96,9 @@ Cypher extension predicates use the current TinkerPop predicate constructor
 through the existing translator extension point. Computed-expression regex
 filters retain whole-string matching (`String.matches`), so `"marko"` matches
 `"mar.*"` and does not match `"ark"`.
+The public `cypherRegex`, `cypherIsString`, `cypherIsNode` and `cypherIsRelationship`
+factories imported by the bundled Gremlin configuration use that same adapter,
+so the Gremlin translation returned by `EXPLAIN` can be replayed.
 
 Cypher results normalize HugeGraph IDs, including
 values nested in collections, maps and paths. Cyclic results and nesting deeper
@@ -98,6 +110,10 @@ TinkerPop 3.5.1 to 3.8.1 upgrade interval before deploying.
 
 ## YAML configuration safety
 
+Jackson JSON and YAML modules share the root BOM version. Fabric8 kubeconfig
+extensions can contain integer and decimal values; the K8s configuration
+regression verifies auto-configuration without contacting a cluster.
+
 This TinkerPop 3.8.1 upgrade uses SnakeYAML 2.2, Spring Boot 2.5.15 and
 Spring Framework 5.3.27. The Boot patch keeps PD and Store's YAML startup
 loader compatible with SnakeYAML 2.x. These versions belong to the upgraded
diff --git a/hugegraph-commons/hugegraph-common/pom.xml b/hugegraph-commons/hugegraph-common/pom.xml
index d703a2407..318d9c22f 100644
--- a/hugegraph-commons/hugegraph-common/pom.xml
+++ b/hugegraph-commons/hugegraph-common/pom.xml
@@ -164,22 +164,18 @@
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-annotations</artifactId>
-            <version>${jackson.version}</version>
         </dependency>
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-core</artifactId>
-            <version>${jackson.version}</version>
         </dependency>
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-databind</artifactId>
-            <version>${jackson.version}</version>
         </dependency>
         <dependency>
             <groupId>com.fasterxml.jackson.module</groupId>
             <artifactId>jackson-module-jaxb-annotations</artifactId>
-            <version>${jackson.version}</version>
             <exclusions>
                 <exclusion>
                     <artifactId>jakarta.xml.bind-api</artifactId>
@@ -190,12 +186,10 @@
         <dependency>
             <groupId>com.fasterxml.jackson.jaxrs</groupId>
             <artifactId>jackson-jaxrs-base</artifactId>
-            <version>${jackson.version}</version>
         </dependency>
         <dependency>
             <groupId>com.fasterxml.jackson.jaxrs</groupId>
             <artifactId>jackson-jaxrs-json-provider</artifactId>
-            <version>${jackson.version}</version>
         </dependency>
 
         <dependency>
diff --git a/hugegraph-commons/pom.xml b/hugegraph-commons/pom.xml
index 7d0e9cfc9..12874e50e 100644
--- a/hugegraph-commons/pom.xml
+++ b/hugegraph-commons/pom.xml
@@ -109,7 +109,6 @@
         <javassist.version>3.28.0-GA</javassist.version>
         <jersey.version>3.0.3</jersey.version>
         <jersey.hk2.version>3.0.3</jersey.hk2.version>
-        <jackson.version>2.14.0-rc1</jackson.version>
         <junit.version>4.13.1</junit.version>
         <mockito.version>4.1.0</mockito.version>
         <jakarta.xml.version>4.0.0-RC2</jakarta.xml.version>
diff --git a/hugegraph-pd/hg-pd-cli/pom.xml b/hugegraph-pd/hg-pd-cli/pom.xml
index ef59e4a6b..ec24ac969 100644
--- a/hugegraph-pd/hg-pd-cli/pom.xml
+++ b/hugegraph-pd/hg-pd-cli/pom.xml
@@ -31,7 +31,6 @@
     <artifactId>hg-pd-cli</artifactId>
 
     <properties>
-        <jackson.version>2.15.2</jackson.version>
     </properties>
 
     <dependencies>
@@ -84,32 +83,26 @@
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-annotations</artifactId>
-            <version>${jackson.version}</version>
         </dependency>
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-core</artifactId>
-            <version>${jackson.version}</version>
         </dependency>
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-databind</artifactId>
-            <version>${jackson.version}</version>
         </dependency>
         <dependency>
             <groupId>com.fasterxml.jackson.module</groupId>
             <artifactId>jackson-module-jaxb-annotations</artifactId>
-            <version>${jackson.version}</version>
         </dependency>
         <dependency>
             <groupId>com.fasterxml.jackson.jaxrs</groupId>
             <artifactId>jackson-jaxrs-base</artifactId>
-            <version>${jackson.version}</version>
         </dependency>
         <dependency>
             <groupId>com.fasterxml.jackson.jaxrs</groupId>
             <artifactId>jackson-jaxrs-json-provider</artifactId>
-            <version>${jackson.version}</version>
         </dependency>
         <dependency>
             <groupId>org.apache.hugegraph</groupId>
diff --git a/hugegraph-pd/hg-pd-test/pom.xml b/hugegraph-pd/hg-pd-test/pom.xml
index 4590eda9a..d9c0ea325 100644
--- a/hugegraph-pd/hg-pd-test/pom.xml
+++ b/hugegraph-pd/hg-pd-test/pom.xml
@@ -138,17 +138,14 @@
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-databind</artifactId>
-            <version>2.13.0</version>
         </dependency>
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-core</artifactId>
-            <version>2.13.0</version>
         </dependency>
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-annotations</artifactId>
-            <version>2.13.0</version>
         </dependency>
 
         <dependency>
diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/opencypher/CypherGremlinPredicates.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/opencypher/CypherGremlinPredicates.java
index 158897d93..53498b720 100644
--- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/opencypher/CypherGremlinPredicates.java
+++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/opencypher/CypherGremlinPredicates.java
@@ -30,21 +30,37 @@ public final class CypherGremlinPredicates extends TraversalGremlinPredicates {
 
     @Override
     public P<Object> regexMatch(Object value) {
-        return predicate(CustomPredicate.cypherRegex, value);
+        return cypherRegex(value);
     }
 
     @Override
     public P<Object> isNode() {
-        return predicate(CustomPredicate.cypherIsNode, null);
+        return cypherIsNode();
     }
 
     @Override
     public P<Object> isRelationship() {
-        return predicate(CustomPredicate.cypherIsRelationship, null);
+        return cypherIsRelationship();
     }
 
     @Override
     public P<Object> isString() {
+        return cypherIsString();
+    }
+
+    public static P<Object> cypherRegex(Object value) {
+        return predicate(CustomPredicate.cypherRegex, value);
+    }
+
+    public static P<Object> cypherIsNode() {
+        return predicate(CustomPredicate.cypherIsNode, null);
+    }
+
+    public static P<Object> cypherIsRelationship() {
+        return predicate(CustomPredicate.cypherIsRelationship, null);
+    }
+
+    public static P<Object> cypherIsString() {
         return predicate(CustomPredicate.cypherIsString, null);
     }
 
diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/opencypher/CypherPlugin.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/opencypher/CypherPlugin.java
index 6d7899dd1..fef7c73bd 100644
--- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/opencypher/CypherPlugin.java
+++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/opencypher/CypherPlugin.java
@@ -40,15 +40,14 @@ import org.apache.tinkerpop.gremlin.jsr223.DefaultImportCustomizer;
 import org.apache.tinkerpop.gremlin.jsr223.GremlinPlugin;
 import org.apache.tinkerpop.gremlin.jsr223.ImportCustomizer;
 import org.opencypher.gremlin.traversal.CustomFunctions;
-import org.opencypher.gremlin.traversal.CustomPredicate;
 
 public class CypherPlugin implements GremlinPlugin {
 
     private static final ImportCustomizer IMPORTS =
             DefaultImportCustomizer.build()
-                                   .addClassImports(CustomPredicate.class)
+                                   .addClassImports(CypherGremlinPredicates.class)
                                    .addMethodImports(
-                                           getDeclaredPublicMethods(CustomPredicate.class))
+                                           getDeclaredPublicMethods(CypherGremlinPredicates.class))
                                    .addClassImports(CustomFunctions.class)
                                    .addMethodImports(
                                            getDeclaredPublicMethods(CustomFunctions.class))
@@ -57,7 +56,8 @@ public class CypherPlugin implements GremlinPlugin {
     private static List<Method> getDeclaredPublicMethods(Class<?> klass) {
         Method[] declaredMethods = klass.getDeclaredMethods();
         return Stream.of(declaredMethods)
-                     .filter(method -> Modifier.isPublic(method.getModifiers()))
+                     .filter(method -> Modifier.isPublic(method.getModifiers()) &&
+                                       Modifier.isStatic(method.getModifiers()))
                      .collect(Collectors.toList());
     }
 
diff --git a/hugegraph-server/hugegraph-core/pom.xml b/hugegraph-server/hugegraph-core/pom.xml
index 4e03478a5..70b7a125a 100644
--- a/hugegraph-server/hugegraph-core/pom.xml
+++ b/hugegraph-server/hugegraph-core/pom.xml
@@ -49,17 +49,14 @@
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-databind</artifactId>
-            <version>2.13.2</version>
         </dependency>
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-core</artifactId>
-            <version>2.13.2</version>
         </dependency>
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-annotations</artifactId>
-            <version>2.15.2</version>
         </dependency>
         <dependency>
             <groupId>io.fabric8</groupId>
diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/io/HugeGraphTypeSerializerRegistryBuilder.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/io/HugeGraphTypeSerializerRegistryBuilder.java
index 831451661..422932e46 100644
--- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/io/HugeGraphTypeSerializerRegistryBuilder.java
+++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/io/HugeGraphTypeSerializerRegistryBuilder.java
@@ -33,6 +33,7 @@ import org.apache.hugegraph.schema.EdgeLabel;
 import org.apache.hugegraph.schema.IndexLabel;
 import org.apache.hugegraph.schema.PropertyKey;
 import org.apache.hugegraph.schema.SchemaElement;
+import org.apache.hugegraph.schema.SchemaManager;
 import org.apache.hugegraph.schema.VertexLabel;
 import org.apache.hugegraph.type.define.HugeKeys;
 import org.apache.hugegraph.util.Blob;
@@ -55,6 +56,10 @@ public final class HugeGraphTypeSerializerRegistryBuilder
             new WireTransformSerializer<>(blob -> ByteBuffer.wrap(blob.bytes()));
     private static final TypeSerializer<SchemaElement> SCHEMA_TRANSFORM_SERIALIZER =
             new WireTransformSerializer<>(HugeGraphTypeSerializerRegistryBuilder::schemaMap);
+    private static final TypeSerializer<SchemaManager> SCHEMA_MANAGER_TRANSFORM_SERIALIZER =
+            new WireTransformSerializer<>(HugeGraphTypeSerializerRegistryBuilder::schemaManagerMap);
+    private static final TypeSerializer<Enum<?>> ENUM_TRANSFORM_SERIALIZER =
+            new WireTransformSerializer<>(Enum::name);
 
     private static final TypeSerializer<Optional<?>> OPTIONAL_TRANSFORM_SERIALIZER =
             new WireTransformSerializer<>(optional -> optional.orElse(null));
@@ -75,6 +80,12 @@ public final class HugeGraphTypeSerializerRegistryBuilder
             if (SchemaElement.class.isAssignableFrom(type)) {
                 return SCHEMA_TRANSFORM_SERIALIZER;
             }
+            if (SchemaManager.class.isAssignableFrom(type)) {
+                return SCHEMA_MANAGER_TRANSFORM_SERIALIZER;
+            }
+            if (isHugeGraphEnum(type)) {
+                return ENUM_TRANSFORM_SERIALIZER;
+            }
             if (Optional.class.isAssignableFrom(type)) {
                 return OPTIONAL_TRANSFORM_SERIALIZER;
             }
@@ -88,6 +99,21 @@ public final class HugeGraphTypeSerializerRegistryBuilder
         });
     }
 
+    private static boolean isHugeGraphEnum(Class<?> type) {
+        // Scope the fallback to HugeGraph; native TinkerPop enums keep their serializers.
+        return Enum.class.isAssignableFrom(type) &&
+               type.getName().startsWith("org.apache.hugegraph.");
+    }
+
+    private static Map<String, Object> schemaManagerMap(SchemaManager schema) {
+        Map<String, Object> result = new LinkedHashMap<>();
+        result.put("propertykeys", schemaValue(schema.getPropertyKeys()));
+        result.put("vertexlabels", schemaValue(schema.getVertexLabels()));
+        result.put("edgelabels", schemaValue(schema.getEdgeLabels()));
+        result.put("indexlabels", schemaValue(schema.getIndexLabels()));
+        return result;
+    }
+
     private static Map<String, Object> schemaMap(SchemaElement schema) {
         // Use the same field names and values as the existing GraphSON schema API.
         GraphSONSchemaSerializer serializer = new GraphSONSchemaSerializer();
@@ -109,9 +135,15 @@ public final class HugeGraphTypeSerializerRegistryBuilder
     }
 
     private static Object schemaValue(Object value) {
-        if (value instanceof Enum) {
+        if (value instanceof Enum && isHugeGraphEnum(value.getClass())) {
             return ((Enum<?>) value).name();
         }
+        if (value instanceof SchemaElement) {
+            return schemaMap((SchemaElement) value);
+        }
+        if (value instanceof SchemaManager) {
+            return schemaManagerMap((SchemaManager) value);
+        }
         if (value instanceof Map) {
             Map<Object, Object> result = new LinkedHashMap<>();
             ((Map<?, ?>) value).forEach((key, item) -> result.put(schemaValue(key), schemaValue(item)));
diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/traversal/optimize/TraversalUtil.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/traversal/optimize/TraversalUtil.java
index dbcd936f6..e426ee781 100644
--- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/traversal/optimize/TraversalUtil.java
+++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/traversal/optimize/TraversalUtil.java
@@ -32,6 +32,7 @@ import java.util.regex.Pattern;
 import org.apache.hugegraph.HugeException;
 import org.apache.hugegraph.HugeGraph;
 import org.apache.hugegraph.backend.BackendException;
+import org.apache.hugegraph.backend.id.EdgeId;
 import org.apache.hugegraph.backend.id.Id;
 import org.apache.hugegraph.backend.id.IdGenerator;
 import org.apache.hugegraph.backend.page.PageInfo;
@@ -46,6 +47,7 @@ import org.apache.hugegraph.iterator.FilterIterator;
 import org.apache.hugegraph.schema.IndexLabel;
 import org.apache.hugegraph.schema.PropertyKey;
 import org.apache.hugegraph.schema.SchemaLabel;
+import org.apache.hugegraph.structure.HugeEdge;
 import org.apache.hugegraph.structure.HugeElement;
 import org.apache.hugegraph.structure.HugeProperty;
 import org.apache.hugegraph.type.HugeType;
@@ -1325,7 +1327,12 @@ public final class TraversalUtil {
                     for (Object value : values) {
                         Object actual = id instanceof IdGenerator.StringId && value instanceof String ?
                                         ((Id) id).asString() : id;
-                        if (Compare.eq.test(actual, value)) {
+                        // Edge lookup accepts its serialized ID as well as EdgeId.
+                        // Preserve that contract in local mixed-ID filters without
+                        // collapsing numeric and string vertex IDs.
+                        Object expected = id instanceof EdgeId &&
+                                          value instanceof String ? HugeEdge.getIdValue(value, true) : value;
+                        if (Compare.eq.test(actual, expected)) {
                             return predicate.getBiPredicate() == Contains.within;
                         }
                     }
diff --git a/hugegraph-server/hugegraph-dist/src/assembly/static/conf/gremlin-server.yaml b/hugegraph-server/hugegraph-dist/src/assembly/static/conf/gremlin-server.yaml
index d906074d0..0b070c98f 100644
--- a/hugegraph-server/hugegraph-dist/src/assembly/static/conf/gremlin-server.yaml
+++ b/hugegraph-server/hugegraph-dist/src/assembly/static/conf/gremlin-server.yaml
@@ -28,7 +28,7 @@ graphs: {
 scriptEngines: {
   gremlin-groovy: {
     staticImports: [
-      org.opencypher.gremlin.process.traversal.CustomPredicates.*',
+      org.apache.hugegraph.opencypher.CypherGremlinPredicates.*,
       org.opencypher.gremlin.traversal.CustomFunctions.*
     ],
     plugins: {
@@ -67,11 +67,11 @@ scriptEngines: {
           org.apache.hugegraph.traversal.optimize.Text,
           org.apache.hugegraph.traversal.optimize.TraversalUtil,
           org.opencypher.gremlin.traversal.CustomFunctions,
-          org.opencypher.gremlin.traversal.CustomPredicate
+          org.apache.hugegraph.opencypher.CypherGremlinPredicates
         ],
         methodImports: [
           java.lang.Math#*,
-          org.opencypher.gremlin.traversal.CustomPredicate#*,
+          org.apache.hugegraph.opencypher.CypherGremlinPredicates#*,
           org.opencypher.gremlin.traversal.CustomFunctions#*
         ]
       },
@@ -109,13 +109,7 @@ serializers:
      }
   }
   # Keep untyped GraphSON before typed GraphSON so application/json stays
-  # mapped to the untyped V1 serializer while explicit typed MIME requests work.
-  - {className: org.apache.tinkerpop.gremlin.util.ser.GraphSONMessageSerializerV1,
-     config: {
-       serializeResultToString: false,
-       ioRegistries: [org.apache.hugegraph.io.HugeGraphIoRegistry]
-     }
-  }
+  # mapped to untyped V1. Typed V1 is disabled because it accepts Java class names.
   - {className: org.apache.tinkerpop.gremlin.util.ser.GraphSONMessageSerializerV2,
      config: {
        serializeResultToString: false,
diff --git a/hugegraph-server/hugegraph-dist/src/assembly/static/conf/remote-objects.yaml b/hugegraph-server/hugegraph-dist/src/assembly/static/conf/remote-objects.yaml
index 55b5bdda4..b8115773f 100644
--- a/hugegraph-server/hugegraph-dist/src/assembly/static/conf/remote-objects.yaml
+++ b/hugegraph-server/hugegraph-dist/src/assembly/static/conf/remote-objects.yaml
@@ -28,9 +28,5 @@ serializer: {
     ]
   }
 }
-# Typed GraphSON V1 fallback for clients that require type metadata for
-# File/Id/simple typed values:
-# use org.apache.tinkerpop.gremlin.util.ser.GraphSONMessageSerializerV1 in
-# place of GraphSONUntypedMessageSerializerV1, and keep HugeGraphIoRegistry.
-# Full HugeGraph internal object typed GraphSON for schema/Vertex/Edge/Path
-# remains follow-up scope; keep untyped serializers for normal remote objects.
+# Keep untyped V1 for the Cypher HTTP JSON path. The bundled Server does not
+# register typed V1 because class-name deserialization can run before authentication.
diff --git a/hugegraph-server/hugegraph-dist/src/assembly/travis/conf-raft1/gremlin-server.yaml b/hugegraph-server/hugegraph-dist/src/assembly/travis/conf-raft1/gremlin-server.yaml
index 68266815e..54e9f3026 100644
--- a/hugegraph-server/hugegraph-dist/src/assembly/travis/conf-raft1/gremlin-server.yaml
+++ b/hugegraph-server/hugegraph-dist/src/assembly/travis/conf-raft1/gremlin-server.yaml
@@ -63,9 +63,10 @@ scriptEngines: {
           org.apache.hugegraph.traversal.optimize.Text,
           org.apache.hugegraph.traversal.optimize.TraversalUtil,
           org.opencypher.gremlin.traversal.CustomFunctions,
-          org.opencypher.gremlin.traversal.CustomPredicate
+          org.apache.hugegraph.opencypher.CypherGremlinPredicates
         ],
-        methodImports: [java.lang.Math#*]
+        methodImports: [java.lang.Math#*,
+                        org.apache.hugegraph.opencypher.CypherGremlinPredicates#*]
       },
       org.apache.tinkerpop.gremlin.jsr223.ScriptFileGremlinPlugin: {
         files: [scripts/empty-sample.groovy]
@@ -100,12 +101,7 @@ serializers:
        ioRegistries: [org.apache.hugegraph.io.HugeGraphIoRegistry]
      }
   }
-  - {className: org.apache.tinkerpop.gremlin.util.ser.GraphSONMessageSerializerV1,
-     config: {
-       serializeResultToString: false,
-       ioRegistries: [org.apache.hugegraph.io.HugeGraphIoRegistry]
-     }
-  }
+  # Typed V1 is disabled because it accepts Java class names.
   - {className: org.apache.tinkerpop.gremlin.util.ser.GraphSONMessageSerializerV2,
      config: {
        serializeResultToString: false,
diff --git a/hugegraph-server/hugegraph-dist/src/assembly/travis/conf-raft2/gremlin-server.yaml b/hugegraph-server/hugegraph-dist/src/assembly/travis/conf-raft2/gremlin-server.yaml
index 97b86a3e9..c2eccf2b3 100644
--- a/hugegraph-server/hugegraph-dist/src/assembly/travis/conf-raft2/gremlin-server.yaml
+++ b/hugegraph-server/hugegraph-dist/src/assembly/travis/conf-raft2/gremlin-server.yaml
@@ -63,9 +63,10 @@ scriptEngines: {
           org.apache.hugegraph.traversal.optimize.Text,
           org.apache.hugegraph.traversal.optimize.TraversalUtil,
           org.opencypher.gremlin.traversal.CustomFunctions,
-          org.opencypher.gremlin.traversal.CustomPredicate
+          org.apache.hugegraph.opencypher.CypherGremlinPredicates
         ],
-        methodImports: [java.lang.Math#*]
+        methodImports: [java.lang.Math#*,
+                        org.apache.hugegraph.opencypher.CypherGremlinPredicates#*]
       },
       org.apache.tinkerpop.gremlin.jsr223.ScriptFileGremlinPlugin: {
         files: [scripts/empty-sample.groovy]
@@ -100,12 +101,7 @@ serializers:
        ioRegistries: [org.apache.hugegraph.io.HugeGraphIoRegistry]
      }
   }
-  - {className: org.apache.tinkerpop.gremlin.util.ser.GraphSONMessageSerializerV1,
-     config: {
-       serializeResultToString: false,
-       ioRegistries: [org.apache.hugegraph.io.HugeGraphIoRegistry]
-     }
-  }
+  # Typed V1 is disabled because it accepts Java class names.
   - {className: org.apache.tinkerpop.gremlin.util.ser.GraphSONMessageSerializerV2,
      config: {
        serializeResultToString: false,
diff --git a/hugegraph-server/hugegraph-dist/src/assembly/travis/conf-raft3/gremlin-server.yaml b/hugegraph-server/hugegraph-dist/src/assembly/travis/conf-raft3/gremlin-server.yaml
index fae1e6eeb..09cba186d 100644
--- a/hugegraph-server/hugegraph-dist/src/assembly/travis/conf-raft3/gremlin-server.yaml
+++ b/hugegraph-server/hugegraph-dist/src/assembly/travis/conf-raft3/gremlin-server.yaml
@@ -63,9 +63,10 @@ scriptEngines: {
           org.apache.hugegraph.traversal.optimize.Text,
           org.apache.hugegraph.traversal.optimize.TraversalUtil,
           org.opencypher.gremlin.traversal.CustomFunctions,
-          org.opencypher.gremlin.traversal.CustomPredicate
+          org.apache.hugegraph.opencypher.CypherGremlinPredicates
         ],
-        methodImports: [java.lang.Math#*]
+        methodImports: [java.lang.Math#*,
+                        org.apache.hugegraph.opencypher.CypherGremlinPredicates#*]
       },
       org.apache.tinkerpop.gremlin.jsr223.ScriptFileGremlinPlugin: {
         files: [scripts/empty-sample.groovy]
@@ -100,12 +101,7 @@ serializers:
        ioRegistries: [org.apache.hugegraph.io.HugeGraphIoRegistry]
      }
   }
-  - {className: org.apache.tinkerpop.gremlin.util.ser.GraphSONMessageSerializerV1,
-     config: {
-       serializeResultToString: false,
-       ioRegistries: [org.apache.hugegraph.io.HugeGraphIoRegistry]
-     }
-  }
+  # Typed V1 is disabled because it accepts Java class names.
   - {className: org.apache.tinkerpop.gremlin.util.ser.GraphSONMessageSerializerV2,
      config: {
        serializeResultToString: false,
diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/core/IdPredicateCoreTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/core/IdPredicateCoreTest.java
index 86c7acc9f..8051f54ba 100644
--- a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/core/IdPredicateCoreTest.java
+++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/core/IdPredicateCoreTest.java
@@ -38,6 +38,7 @@ import org.apache.tinkerpop.gremlin.process.traversal.step.GValue;
 import org.apache.tinkerpop.gremlin.process.traversal.step.filter.HasStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.GraphStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.util.HasContainer;
+import org.apache.tinkerpop.gremlin.structure.Edge;
 import org.apache.tinkerpop.gremlin.structure.T;
 import org.apache.tinkerpop.gremlin.structure.Vertex;
 import org.junit.Test;
@@ -287,6 +288,38 @@ public class IdPredicateCoreTest extends BaseCoreTest {
         }
     }
 
+    @Test
+    public void testMixedEdgeIdCollections() {
+        graph().schema().vertexLabel("edge-id").useCustomizeNumberId().create();
+        graph().schema().edgeLabel("mixed-id-edge").sourceLabel("edge-id").targetLabel("edge-id").create();
+        Vertex first = graph().addVertex(T.label, "edge-id", T.id, 101L);
+        Vertex second = graph().addVertex(T.label, "edge-id", T.id, 102L);
+        Vertex third = graph().addVertex(T.label, "edge-id", T.id, 103L);
+        Edge one = first.addEdge("mixed-id-edge", second);
+        Edge two = first.addEdge("mixed-id-edge", third);
+        Edge excluded = second.addEdge("mixed-id-edge", third);
+        commitTx();
+        List<List<Object>> collections = Arrays.asList(Arrays.asList(one.id().toString(), two.id()),
+                                                       Arrays.asList(one.id(), two.id().toString()),
+                                                       Arrays.asList(one.id(), two.id()),
+                                                       Arrays.asList(one.id().toString(), two.id().toString()));
+        for (GraphTraversalSource source : this.sources()) {
+            for (List<Object> ids : collections) {
+                Assert.assertEquals(new HashSet<>(Arrays.asList(one.id(), two.id())),
+                                    new HashSet<>(graph().traversal().E().hasId(P.within(ids)).id().toList()));
+                GraphTraversal<Edge, Edge> local = source.E().hasId(P.not(P.without(ids)));
+                localIdContainer(local);
+                Assert.assertEquals(new HashSet<>(Arrays.asList(one, two)), new HashSet<>(local.toList()));
+                Assert.assertEquals(2L, source.E().hasId(P.not(P.without(ids))).count().next().longValue());
+                Assert.assertEquals(Collections.singletonList(excluded),
+                                    source.E().hasId(P.not(P.within(ids))).toList());
+                Assert.assertEquals(1L, source.E().hasId(P.not(P.within(ids))).count().next().longValue());
+            }
+            Assert.assertEquals(Collections.singletonList(one), source.E()
+                    .hasId(P.not(P.without(Arrays.asList("invalid", one.id())))).toList());
+        }
+    }
+
     private void assertHeterogeneousIdCollection(GraphTraversalSource source, List<Object> operands,
                                                  Vertex excluded, Vertex... expected) {
         P<Object> within = P.within(operands);
diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/UnitTestSuite.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/UnitTestSuite.java
index 428e4c138..f772ffd92 100644
--- a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/UnitTestSuite.java
+++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/UnitTestSuite.java
@@ -46,6 +46,7 @@ import org.apache.hugegraph.unit.cache.CachedSchemaTransactionTest;
 import org.apache.hugegraph.unit.cache.RamTableTest;
 import org.apache.hugegraph.unit.cmd.InitStoreConfigTest;
 import org.apache.hugegraph.unit.config.GremlinConfigCompatibilityTest;
+import org.apache.hugegraph.unit.config.GraphBinarySchemaCompatibilityTest;
 import org.apache.hugegraph.unit.config.K8sResourceQuotaYamlTest;
 import org.apache.hugegraph.unit.core.AnalyzerTest;
 import org.apache.hugegraph.unit.core.BackendMutationTest;
@@ -216,6 +217,7 @@ import org.junit.runners.Suite;
 
         /* config */
         GremlinConfigCompatibilityTest.class,
+        GraphBinarySchemaCompatibilityTest.class,
         K8sResourceQuotaYamlTest.class,
         /* rocksdb */
         RocksDBSessionsTest.class,
diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/config/GraphBinarySchemaCompatibilityTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/config/GraphBinarySchemaCompatibilityTest.java
new file mode 100644
index 000000000..9c5a84df0
--- /dev/null
+++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/config/GraphBinarySchemaCompatibilityTest.java
@@ -0,0 +1,165 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hugegraph.unit.config;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+import org.apache.hugegraph.backend.id.IdGenerator;
+import org.apache.hugegraph.backend.tx.ISchemaTransaction;
+import org.apache.hugegraph.io.HugeGraphTypeSerializerRegistryBuilder;
+import org.apache.hugegraph.schema.EdgeLabel;
+import org.apache.hugegraph.schema.IndexLabel;
+import org.apache.hugegraph.schema.PropertyKey;
+import org.apache.hugegraph.schema.SchemaManager;
+import org.apache.hugegraph.schema.VertexLabel;
+import org.apache.hugegraph.testutil.Assert;
+import org.apache.hugegraph.type.HugeType;
+import org.apache.hugegraph.type.define.Cardinality;
+import org.apache.hugegraph.type.define.DataType;
+import org.apache.hugegraph.type.define.Directions;
+import org.apache.hugegraph.type.define.Frequency;
+import org.apache.hugegraph.type.define.GraphMode;
+import org.apache.hugegraph.type.define.IdStrategy;
+import org.apache.hugegraph.type.define.IndexType;
+import org.apache.hugegraph.unit.BaseUnitTest;
+import org.apache.hugegraph.unit.FakeObjects;
+import org.apache.tinkerpop.gremlin.process.traversal.Order;
+import org.apache.tinkerpop.gremlin.structure.Direction;
+import org.apache.tinkerpop.gremlin.util.message.ResponseMessage;
+import org.apache.tinkerpop.gremlin.util.message.ResponseStatusCode;
+import org.apache.tinkerpop.gremlin.util.ser.GraphBinaryMessageSerializerV1;
+import org.junit.Test;
+import org.mockito.Mockito;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufAllocator;
+
+public class GraphBinarySchemaCompatibilityTest extends BaseUnitTest {
+
+    @Test
+    public void testHugeGraphEnumsUseNamesWithStandardClient() throws Exception {
+        Assert.assertEquals("OUT", roundTrip(Directions.OUT));
+        // DataType constants have individual enum subclasses.
+        Assert.assertEquals("TEXT", roundTrip(DataType.TEXT));
+        Assert.assertEquals("SINGLE", roundTrip(Cardinality.SINGLE));
+        Assert.assertEquals("NONE", roundTrip(GraphMode.NONE));
+        Assert.assertEquals("VERTEX_LABEL", roundTrip(HugeType.VERTEX_LABEL));
+    }
+
+    @Test
+    public void testNestedEnumsPreserveNativeTinkerPopEnums() throws Exception {
+        Map<Object, Object> result = Map.of(
+                Directions.OUT, List.of(DataType.TEXT, Direction.OUT, Order.asc));
+        Assert.assertEquals(Map.of("OUT", List.of("TEXT", Direction.OUT, Order.asc)),
+                            roundTrip(result));
+        Assert.assertEquals(Direction.IN, roundTrip(Direction.IN));
+        Assert.assertEquals(Order.desc, roundTrip(Order.desc));
+    }
+
+    @Test
+    public void testEmptySchemaManagerUsesAllFourLists() throws Exception {
+        FakeObjects objects = new FakeObjects();
+        SchemaManager schema = schemaManager(objects);
+        Assert.assertEquals(Map.of("propertykeys", List.of(),
+                                   "vertexlabels", List.of(),
+                                   "edgelabels", List.of(),
+                                   "indexlabels", List.of()), roundTrip(schema));
+    }
+
+    @Test
+    public void testSchemaManagerConvertsAllSchemasAndHidesInternalNames() throws Exception {
+        FakeObjects objects = new FakeObjects();
+        PropertyKey key = objects.newPropertyKey(IdGenerator.of(1), "name");
+        PropertyKey hidden = objects.newPropertyKey(IdGenerator.of(2), "~internal");
+        VertexLabel vertex = objects.newVertexLabel(IdGenerator.of(3), "person",
+                                                    IdStrategy.AUTOMATIC, key.id());
+        EdgeLabel edge = objects.newEdgeLabel(IdGenerator.of(4), "knows", Frequency.SINGLE,
+                                              vertex.id(), vertex.id(), key.id());
+        IndexLabel index = objects.newIndexLabel(IdGenerator.of(5), "by_name",
+                                                 HugeType.VERTEX_LABEL, vertex.id(),
+                                                 IndexType.SECONDARY, key.id());
+        Mockito.when(objects.graph().propertyKeys()).thenReturn(List.of(key, hidden));
+        Mockito.when(objects.graph().vertexLabels()).thenReturn(List.of(vertex));
+        Mockito.when(objects.graph().edgeLabels()).thenReturn(List.of(edge));
+        Mockito.when(objects.graph().indexLabels()).thenReturn(List.of(index));
+
+        Map<?, ?> result = (Map<?, ?>) roundTrip(schemaManager(objects));
+        assertSchema(result, "propertykeys", "name");
+        assertSchema(result, "vertexlabels", "person");
+        assertSchema(result, "edgelabels", "knows");
+        assertSchema(result, "indexlabels", "by_name");
+        Map<?, ?> property = (Map<?, ?>) ((List<?>) result.get("propertykeys")).get(0);
+        Assert.assertEquals("TEXT", property.get("data_type"));
+        Assert.assertEquals("SINGLE", property.get("cardinality"));
+    }
+
+    @Test
+    public void testSchemaManagerAndSchemaElementsInsideCollections() throws Exception {
+        FakeObjects objects = new FakeObjects();
+        PropertyKey key = objects.newPropertyKey(IdGenerator.of(1), "name");
+        Mockito.when(objects.graph().propertyKeys()).thenReturn(List.of(key));
+        SchemaManager schema = schemaManager(objects);
+        Map<?, ?> result = (Map<?, ?>) roundTrip(Map.of("nested", List.of(schema, key)));
+        List<?> nested = (List<?>) result.get("nested");
+        assertSchema((Map<?, ?>) nested.get(0), "propertykeys", "name");
+        Assert.assertEquals("name", ((Map<?, ?>) nested.get(1)).get("name"));
+    }
+
+    @Test
+    public void testNestedSchemaMetadataKeepsStandardWireValues() throws Exception {
+        FakeObjects objects = new FakeObjects();
+        PropertyKey key = objects.newPropertyKey(IdGenerator.of(1), "name");
+        PropertyKey child = objects.newPropertyKey(IdGenerator.of(2), "age", DataType.INT);
+        key.userdata("nested", Map.of("key", child,
+                                    "values", List.of(Directions.OUT, Direction.OUT, Order.asc)));
+        Map<?, ?> result = (Map<?, ?>) roundTrip(key);
+        Map<?, ?> metadata = (Map<?, ?>) ((Map<?, ?>) result.get("user_data")).get("nested");
+        Assert.assertEquals("age", ((Map<?, ?>) metadata.get("key")).get("name"));
+        Assert.assertEquals(List.of("OUT", Direction.OUT, Order.asc), metadata.get("values"));
+    }
+
+    private static SchemaManager schemaManager(FakeObjects objects) {
+        return new SchemaManager(Mockito.mock(ISchemaTransaction.class), objects.graph());
+    }
+
+    private static void assertSchema(Map<?, ?> result, String type, String name) {
+        List<?> schemas = (List<?>) result.get(type);
+        Assert.assertEquals(1, schemas.size());
+        Assert.assertEquals(name, ((Map<?, ?>) schemas.get(0)).get("name"));
+    }
+
+    private static Object roundTrip(Object value) throws Exception {
+        GraphBinaryMessageSerializerV1 server = new GraphBinaryMessageSerializerV1();
+        server.configure(Map.of("builder", HugeGraphTypeSerializerRegistryBuilder.class.getName()),
+                         Collections.emptyMap());
+        GraphBinaryMessageSerializerV1 client = new GraphBinaryMessageSerializerV1();
+        ResponseMessage response = ResponseMessage.build(UUID.randomUUID())
+                                                  .code(ResponseStatusCode.SUCCESS)
+                                                  .result(value)
+                                                  .create();
+        ByteBuf buffer = server.serializeResponseAsBinary(response, ByteBufAllocator.DEFAULT);
+        try {
+            return client.deserializeResponse(buffer).getResult().getData();
+        } finally {
+            buffer.release();
+        }
+    }
+}
diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/config/GremlinConfigCompatibilityTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/config/GremlinConfigCompatibilityTest.java
index 8ed1f8eff..1ab85c890 100644
--- a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/config/GremlinConfigCompatibilityTest.java
+++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/config/GremlinConfigCompatibilityTest.java
@@ -29,6 +29,7 @@ import java.nio.file.Paths;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -54,6 +55,8 @@ import org.apache.hugegraph.unit.FakeObjects;
 import org.apache.hugegraph.util.Blob;
 import org.apache.hugegraph.util.JsonUtil;
 import org.apache.tinkerpop.gremlin.driver.Result;
+import org.apache.tinkerpop.gremlin.groovy.jsr223.GremlinGroovyScriptEngine;
+import org.apache.tinkerpop.gremlin.jsr223.ImportGremlinPlugin;
 import org.apache.tinkerpop.gremlin.process.traversal.P;
 import org.apache.tinkerpop.gremlin.process.traversal.step.util.MutablePath;
 import org.apache.tinkerpop.gremlin.process.traversal.step.util.Tree;
@@ -70,6 +73,7 @@ import org.apache.tinkerpop.gremlin.structure.util.detached.DetachedVertexProper
 import org.apache.tinkerpop.gremlin.structure.util.reference.ReferenceEdge;
 import org.apache.tinkerpop.gremlin.structure.util.reference.ReferenceVertex;
 import org.apache.tinkerpop.gremlin.util.MessageSerializer;
+import org.apache.tinkerpop.gremlin.util.message.RequestMessage;
 import org.apache.tinkerpop.gremlin.util.message.ResponseMessage;
 import org.apache.tinkerpop.gremlin.util.message.ResponseStatusCode;
 import org.apache.tinkerpop.gremlin.util.ser.GraphBinaryMessageSerializerV1;
@@ -154,13 +158,11 @@ public class GremlinConfigCompatibilityTest extends BaseUnitTest {
     );
     private static final List<String> TYPED_FALLBACK_SERIALIZERS =
             Arrays.asList(
-                    SERIALIZER_PACKAGE + "GraphSONMessageSerializerV1",
                     SERIALIZER_PACKAGE + "GraphSONMessageSerializerV2",
                     SERIALIZER_PACKAGE + "GraphSONMessageSerializerV3"
             );
     private static final List<String> TYPED_GRAPHSON_MIME_TYPES =
             Arrays.asList(
-                    "application/vnd.gremlin-v1.0+json",
                     "application/vnd.gremlin-v2.0+json",
                     "application/vnd.gremlin-v3.0+json"
             );
@@ -231,6 +233,70 @@ public class GremlinConfigCompatibilityTest extends BaseUnitTest {
         }
     }
 
+    @Test
+    public void testGremlinServerConfigVariantsRejectTypedGraphSONV1() throws Exception {
+        String javaType = UnexpectedGraphSONType.class.getName();
+        String requestJson = "{\"requestId\":\"" + UUID.randomUUID() +
+                             "\",\"op\":\"eval\",\"processor\":\"\",\"args\":{" +
+                             "\"gremlin\":\"1\",\"bindings\":{\"value\":{\"@class\":\"" +
+                             javaType + "\"}}}}";
+        for (String variant : GREMLIN_SERVER_CONFIG_VARIANTS) {
+            Settings settings = Settings.read(serverAssemblyPath().resolve(variant).toString());
+            Map<String, String> mimeTypes = graphSONMimeTypes(settings);
+            Assert.assertFalse(variant + " must not expose Java class-name typing",
+                               mimeTypes.containsKey("application/vnd.gremlin-v1.0+json"));
+            for (Settings.SerializerSettings setting : settings.serializers) {
+                Assert.assertNotEquals(variant, SERIALIZER_PACKAGE + "GraphSONMessageSerializerV1",
+                                       setting.className);
+                if (!GRAPHSON_UNTYPED_V1.equals(setting.className)) {
+                    continue;
+                }
+                MessageTextSerializer<?> serializer = newTextSerializer(setting.className);
+                serializer.configure(config(setting.config), Collections.emptyMap());
+                UnexpectedGraphSONType.constructions = 0;
+                RequestMessage request = serializer.deserializeRequest(requestJson);
+                Map<?, ?> bindings = (Map<?, ?>) request.getArgs().get("bindings");
+                Assert.assertEquals(variant, Map.of("@class", javaType), bindings.get("value"));
+                Assert.assertEquals(variant, 0, UnexpectedGraphSONType.constructions);
+            }
+            Assert.assertEquals(variant, GRAPHSON_UNTYPED_V1, mimeTypes.get("application/json"));
+        }
+    }
+
+    public static class UnexpectedGraphSONType {
+
+        private static int constructions;
+
+        public UnexpectedGraphSONType() {
+            constructions++;
+        }
+    }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void testGremlinServerConfigVariantsImportCompatibleCypherFactories() throws Exception {
+        String factory = "org.apache.hugegraph.opencypher.CypherGremlinPredicates";
+        for (String variant : GREMLIN_SERVER_CONFIG_VARIANTS) {
+            Settings settings = Settings.read(serverAssemblyPath().resolve(variant).toString());
+            Map<String, Object> imports = settings.scriptEngines.get("gremlin-groovy")
+                                                  .plugins.get(ImportGremlinPlugin.class.getName());
+            Collection<String> classes = (Collection<String>) imports.get("classImports");
+            Collection<String> methods = (Collection<String>) imports.get("methodImports");
+            Assert.assertTrue(variant, classes.contains(factory));
+            Assert.assertTrue(variant, methods.contains(factory + "#*"));
+            Assert.assertFalse(variant, classes.contains("org.opencypher.gremlin.traversal.CustomPredicate"));
+            ImportGremlinPlugin plugin = ImportGremlinPlugin.build().classImports(classes)
+                                                           .methodImports(methods).create();
+            GremlinGroovyScriptEngine engine = new GremlinGroovyScriptEngine(
+                    plugin.getCustomizers("gremlin-groovy").orElseThrow());
+            Assert.assertEquals(variant, Arrays.asList(true, true, false, false),
+                                engine.eval("[cypherRegex('mar.*').test('marko'), " +
+                                            "cypherIsString().test('marko'), " +
+                                            "cypherIsNode().test(null), " +
+                                            "cypherIsRelationship().test(null)]"));
+        }
+    }
+
     @Test
     public void testGremlinServerConfigVariantsUseHugeGraphBinaryBuilder()
             throws Exception {
@@ -299,10 +365,7 @@ public class GremlinConfigCompatibilityTest extends BaseUnitTest {
             } else {
                 foundUntyped = true;
             }
-            assertCanSerializeHugeGraphTypes(
-                    serializer,
-                    typed && usesStableGraphSONTypes(
-                            serializerSettings.className));
+            assertCanSerializeHugeGraphTypes(serializer, typed);
         }
 
         Assert.assertTrue("No untyped GraphSON serializer settings found in " +
@@ -685,18 +748,6 @@ public class GremlinConfigCompatibilityTest extends BaseUnitTest {
             }
             MessageTextSerializer<?> serializer = newTextSerializer(setting.className);
             serializer.configure(config(setting.config), Collections.emptyMap());
-            if (setting.className.endsWith("GraphSONMessageSerializerV1")) {
-                // V1's legacy typed format returns ID-keyed maps, rather than a Tree.
-                Map<?, ?> elements = (Map<?, ?>) roundTripResponse(serializer, elementTree()).getResult().getData();
-                Assert.assertEquals(1, elements.size());
-                Map<?, ?> entry = (Map<?, ?>) elements.values().iterator().next();
-                Map<?, ?> vertex = (Map<?, ?>) entry.get("key");
-                Assert.assertEquals("person", vertex.get("label"));
-                Assert.assertContains("marko", JsonUtil.toJson(vertex));
-                Assert.assertInstanceOf(Map.class, entry.get("value"));
-                serializers++;
-                continue;
-            }
             Object data = roundTripResponse(serializer, scalar).getResult().getData();
             Assert.assertInstanceOf(Tree.class, data);
             Assert.assertEquals(scalar, data);
@@ -710,7 +761,7 @@ public class GremlinConfigCompatibilityTest extends BaseUnitTest {
             Assert.assertEquals(0.5D, (Double) edge.value("weight"), 0.0D);
             serializers++;
         }
-        Assert.assertEquals(3, serializers);
+        Assert.assertEquals(2, serializers);
     }
 
     @Test
@@ -1185,12 +1236,6 @@ public class GremlinConfigCompatibilityTest extends BaseUnitTest {
         }
     }
 
-    private static boolean usesStableGraphSONTypes(String serializer) {
-        // GraphSON V1 uses legacy @class wrapping; assert stable
-        // hugegraph:* @type names for V2/V3 typed fallback serializers.
-        return !serializer.endsWith("GraphSONMessageSerializerV1");
-    }
-
     private static void assertCanRoundTripHugeGraphIds(
             String serializerName, MessageTextSerializer<?> serializer)
             throws Exception {
diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/config/K8sResourceQuotaYamlTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/config/K8sResourceQuotaYamlTest.java
index 10e22d374..387b8a976 100644
--- a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/config/K8sResourceQuotaYamlTest.java
+++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/config/K8sResourceQuotaYamlTest.java
@@ -117,7 +117,9 @@ public class K8sResourceQuotaYamlTest {
                                      "contexts:\n- name: test-context\n" +
                                      "  context: {cluster: test, user: test-user, " +
                                      "namespace: hugegraph-test}\n" +
-                                     "current-context: test-context\n").getBytes(StandardCharsets.UTF_8));
+                                     "current-context: test-context\n" +
+                                     "extensions:\n- name: fixture-extension\n" +
+                                     "  extension: {ratio: 0.5, count: 1}\n").getBytes(StandardCharsets.UTF_8));
             properties.forEach((key, value) -> {
                 originals.put(key, System.getProperty(key));
                 System.setProperty(key, value);
diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/opencypher/CypherGremlinPredicatesTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/opencypher/CypherGremlinPredicatesTest.java
index 5c1b3949a..5bf7d6d0d 100644
--- a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/opencypher/CypherGremlinPredicatesTest.java
+++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/opencypher/CypherGremlinPredicatesTest.java
@@ -17,12 +17,27 @@
 
 package org.apache.hugegraph.unit.opencypher;
 
+import java.util.Collections;
+import java.util.List;
+
+import javax.script.Bindings;
+import javax.script.ScriptException;
+
 import org.apache.hugegraph.opencypher.CypherGremlinPredicates;
+import org.apache.hugegraph.opencypher.CypherPlugin;
 import org.apache.hugegraph.testutil.Assert;
 import org.apache.hugegraph.unit.BaseUnitTest;
+import org.apache.tinkerpop.gremlin.groovy.jsr223.GremlinGroovyScriptEngine;
+import org.apache.tinkerpop.gremlin.jsr223.Customizer;
+import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
+import org.apache.tinkerpop.gremlin.structure.util.empty.EmptyGraph;
 import org.apache.tinkerpop.gremlin.structure.util.reference.ReferenceEdge;
 import org.apache.tinkerpop.gremlin.structure.util.reference.ReferenceVertex;
 import org.junit.Test;
+import org.opencypher.gremlin.translation.CypherAst;
+import org.opencypher.gremlin.translation.StatementOption;
+import org.opencypher.gremlin.translation.groovy.GroovyPredicate;
+import org.opencypher.gremlin.translation.translator.Translator;
 
 public class CypherGremlinPredicatesTest extends BaseUnitTest {
 
@@ -50,4 +65,48 @@ public class CypherGremlinPredicatesTest extends BaseUnitTest {
         Assert.assertFalse(predicates.isString().test(42));
         Assert.assertFalse(predicates.isString().test(source));
     }
+
+    @Test
+    public void testPublicFactoriesThroughPluginImports() throws ScriptException {
+        GremlinGroovyScriptEngine engine = pluginEngine();
+        Bindings bindings = engine.createBindings();
+        ReferenceVertex source = new ReferenceVertex("source", "person");
+        ReferenceVertex target = new ReferenceVertex("target", "person");
+        bindings.put("vertex", source);
+        bindings.put("edge", new ReferenceEdge("edge", "knows", source, target));
+        Assert.assertEquals(true, engine.eval("cypherRegex('mar.*').test('marko')", bindings));
+        Assert.assertEquals(false, engine.eval("cypherRegex('ark').test('marko')", bindings));
+        Assert.assertEquals(true, engine.eval("cypherIsNode().test(vertex)", bindings));
+        Assert.assertEquals(false, engine.eval("cypherIsNode().test(edge)", bindings));
+        Assert.assertEquals(true, engine.eval("cypherIsRelationship().test(edge)", bindings));
+        Assert.assertEquals(false, engine.eval("cypherIsRelationship().test(vertex)", bindings));
+        Assert.assertEquals(true, engine.eval("cypherIsString().test('marko')", bindings));
+        Assert.assertEquals(false, engine.eval("cypherIsString().test(42)", bindings));
+    }
+
+    @Test
+    public void testExplainGremlinReplaysUsingPluginImports() throws ScriptException {
+        CypherAst ast = CypherAst.parse("EXPLAIN UNWIND ['marko', 'peter'] AS name " +
+                                       "WITH name WHERE name =~ 'mar.*' RETURN name");
+        Assert.assertTrue(ast.getOptions().contains(StatementOption.EXPLAIN));
+        Translator<String, GroovyPredicate> translator = Translator.builder()
+                                                                   .gremlinGroovy()
+                                                                   .build("gremlin+cfog_server_extensions+" +
+                                                                          "inline_parameters");
+        String gremlin = ast.buildTranslation(translator);
+        Assert.assertTrue(gremlin.contains("cypherRegex("));
+        GremlinGroovyScriptEngine engine = pluginEngine();
+        Bindings bindings = engine.createBindings();
+        bindings.put("g", EmptyGraph.instance().traversal());
+        GraphTraversal<?, ?> traversal = (GraphTraversal<?, ?>) engine.eval(gremlin, bindings);
+        List<?> result = traversal.toList();
+        Assert.assertEquals(Collections.singletonList(Collections.singletonMap("name", "marko")),
+                            result);
+    }
+
+    private static GremlinGroovyScriptEngine pluginEngine() {
+        Customizer[] customizers = CypherPlugin.instance().getCustomizers("gremlin-groovy").get();
+        return new GremlinGroovyScriptEngine(customizers);
+    }
+
 }
diff --git a/hugegraph-store/hg-store-client/pom.xml b/hugegraph-store/hg-store-client/pom.xml
index 736bc3679..d3d5eae41 100644
--- a/hugegraph-store/hg-store-client/pom.xml
+++ b/hugegraph-store/hg-store-client/pom.xml
@@ -88,7 +88,6 @@
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-databind</artifactId>
-            <version>2.13.0</version>
             <scope>test</scope>
         </dependency>
         <dependency>
diff --git a/hugegraph-store/hg-store-test/pom.xml b/hugegraph-store/hg-store-test/pom.xml
index a668c14f6..bf1bc6f30 100644
--- a/hugegraph-store/hg-store-test/pom.xml
+++ b/hugegraph-store/hg-store-test/pom.xml
@@ -120,7 +120,6 @@
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-databind</artifactId>
-            <version>2.13.0</version>
         </dependency>
 
         <dependency>
@@ -148,12 +147,10 @@
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-core</artifactId>
-            <version>2.13.0</version>
         </dependency>
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-annotations</artifactId>
-            <version>2.13.0</version>
         </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
diff --git a/install-dist/release-docs/LICENSE b/install-dist/release-docs/LICENSE
index aaa738a39..c89ada323 100644
--- a/install-dist/release-docs/LICENSE
+++ b/install-dist/release-docs/LICENSE
@@ -291,8 +291,10 @@ the corresponding per-component license file.
     https://central.sonatype.com/artifact/com.fasterxml.jackson.core/jackson-databind/2.15.2 -> Apache 2.0
     https://central.sonatype.com/artifact/com.fasterxml.jackson.dataformat/jackson-dataformat-yaml/2.15.2 -> Apache 2.0
     https://central.sonatype.com/artifact/com.fasterxml.jackson.datatype/jackson-datatype-jdk8/2.12.7 -> Apache 2.0
+    https://central.sonatype.com/artifact/com.fasterxml.jackson.datatype/jackson-datatype-jdk8/2.15.2 -> Apache 2.0
     https://central.sonatype.com/artifact/com.fasterxml.jackson.datatype/jackson-datatype-jsr310/2.11.2 -> Apache 2.0
     https://central.sonatype.com/artifact/com.fasterxml.jackson.datatype/jackson-datatype-jsr310/2.12.7 -> Apache 2.0
+    https://central.sonatype.com/artifact/com.fasterxml.jackson.datatype/jackson-datatype-jsr310/2.15.2 -> Apache 2.0
     https://central.sonatype.com/artifact/com.fasterxml.jackson.jakarta.rs/jackson-jakarta-rs-base/2.15.2 -> Apache 2.0
     https://central.sonatype.com/artifact/com.fasterxml.jackson.jakarta.rs/jackson-jakarta-rs-json-provider/2.15.2 -> Apache 2.0
     https://central.sonatype.com/artifact/com.fasterxml.jackson.jaxrs/jackson-jaxrs-base/2.14.0-rc1 -> Apache 2.0
@@ -303,6 +305,7 @@ the corresponding per-component license file.
     https://central.sonatype.com/artifact/com.fasterxml.jackson.module/jackson-module-jaxb-annotations/2.14.0-rc1 -> Apache 2.0
     https://central.sonatype.com/artifact/com.fasterxml.jackson.module/jackson-module-jaxb-annotations/2.15.2 -> Apache 2.0
     https://central.sonatype.com/artifact/com.fasterxml.jackson.module/jackson-module-parameter-names/2.12.7 -> Apache 2.0
+    https://central.sonatype.com/artifact/com.fasterxml.jackson.module/jackson-module-parameter-names/2.15.2 -> Apache 2.0
     https://central.sonatype.com/artifact/com.github.ben-manes.caffeine/caffeine/2.3.1 -> Apache 2.0
     https://central.sonatype.com/artifact/com.github.javaparser/javaparser-core/3.26.3 -> Apache 2.0
     https://central.sonatype.com/artifact/com.github.jbellis/jamm/0.3.2 -> Apache 2.0
diff --git a/install-dist/release-docs/NOTICE b/install-dist/release-docs/NOTICE
index 521dfb13a..8f505aa26 100644
--- a/install-dist/release-docs/NOTICE
+++ b/install-dist/release-docs/NOTICE
@@ -3037,3 +3037,72 @@ as per accompanying LICENSE file.
 A list of contributors may be found from CREDITS file, which is included
 in some artifacts (usually source distributions); but is always available
 from the source code management (SCM) system project uses.
+
+========================================================================
+
+jackson-datatype-jdk8-2.15.2 NOTICE
+
+========================================================================
+# Jackson JSON processor
+
+Jackson is a high-performance, Free/Open Source JSON processing library.
+It was originally written by Tatu Saloranta (tatu.saloranta@iki.fi), and has
+been in development since 2007.
+It is currently developed by a community of developers.
+
+## Licensing
+
+Jackson components are licensed under Apache (Software) License, version 2.0,
+as per accompanying LICENSE file.
+
+## Credits
+
+A list of contributors may be found from CREDITS file, which is included
+in some artifacts (usually source distributions); but is always available
+from the source code management (SCM) system project uses.
+
+========================================================================
+
+jackson-datatype-jsr310-2.15.2 NOTICE
+
+========================================================================
+# Jackson JSON processor
+
+Jackson is a high-performance, Free/Open Source JSON processing library.
+It was originally written by Tatu Saloranta (tatu.saloranta@iki.fi), and has
+been in development since 2007.
+It is currently developed by a community of developers.
+
+## Licensing
+
+Jackson components are licensed under Apache (Software) License, version 2.0,
+as per accompanying LICENSE file.
+
+## Credits
+
+A list of contributors may be found from CREDITS file, which is included
+in some artifacts (usually source distributions); but is always available
+from the source code management (SCM) system project uses.
+
+========================================================================
+
+jackson-module-parameter-names-2.15.2 NOTICE
+
+========================================================================
+# Jackson JSON processor
+
+Jackson is a high-performance, Free/Open Source JSON processing library.
+It was originally written by Tatu Saloranta (tatu.saloranta@iki.fi), and has
+been in development since 2007.
+It is currently developed by a community of developers.
+
+## Licensing
+
+Jackson components are licensed under Apache (Software) License, version 2.0,
+as per accompanying LICENSE file.
+
+## Credits
+
+A list of contributors may be found from CREDITS file, which is included
+in some artifacts (usually source distributions); but is always available
+from the source code management (SCM) system project uses.
diff --git a/install-dist/release-docs/licenses/LICENSE-jackson-datatype-jdk8-2.15.2.txt b/install-dist/release-docs/licenses/LICENSE-jackson-datatype-jdk8-2.15.2.txt
new file mode 100644
index 000000000..0a97ea4ff
--- /dev/null
+++ b/install-dist/release-docs/licenses/LICENSE-jackson-datatype-jdk8-2.15.2.txt
@@ -0,0 +1,8 @@
+This copy of Jackson JSON processor Java 8 datatype module is licensed under the
+Apache (Software) License, version 2.0 ("the License").
+See the License for details about distribution rights, and the
+specific rights regarding derivative works.
+
+You may obtain a copy of the License at:
+
+http://www.apache.org/licenses/LICENSE-2.0
diff --git a/install-dist/release-docs/licenses/LICENSE-jackson-module-parameter-names-2.15.2.txt b/install-dist/release-docs/licenses/LICENSE-jackson-module-parameter-names-2.15.2.txt
new file mode 100644
index 000000000..f49b9ee83
--- /dev/null
+++ b/install-dist/release-docs/licenses/LICENSE-jackson-module-parameter-names-2.15.2.txt
@@ -0,0 +1,8 @@
+This copy of Jackson JSON processor Java 8 parameter names module is licensed under the
+Apache (Software) License, version 2.0 ("the License").
+See the License for details about distribution rights, and the
+specific rights regarding derivative works.
+
+You may obtain a copy of the License at:
+
+http://www.apache.org/licenses/LICENSE-2.0
diff --git a/install-dist/scripts/dependency/known-dependencies.txt b/install-dist/scripts/dependency/known-dependencies.txt
index fc7ece427..a38179ed4 100644
--- a/install-dist/scripts/dependency/known-dependencies.txt
+++ b/install-dist/scripts/dependency/known-dependencies.txt
@@ -210,8 +210,10 @@ jackson-databind-2.14.0-rc1.jar
 jackson-databind-2.15.2.jar
 jackson-dataformat-yaml-2.15.2.jar
 jackson-datatype-jdk8-2.12.7.jar
+jackson-datatype-jdk8-2.15.2.jar
 jackson-datatype-jsr310-2.11.2.jar
 jackson-datatype-jsr310-2.12.7.jar
+jackson-datatype-jsr310-2.15.2.jar
 jackson-jakarta-rs-base-2.15.2.jar
 jackson-jakarta-rs-json-provider-2.15.2.jar
 jackson-jaxrs-base-2.14.0-rc1.jar
@@ -222,6 +224,7 @@ jackson-module-jakarta-xmlbind-annotations-2.15.2.jar
 jackson-module-jaxb-annotations-2.14.0-rc1.jar
 jackson-module-jaxb-annotations-2.15.2.jar
 jackson-module-parameter-names-2.12.7.jar
+jackson-module-parameter-names-2.15.2.jar
 jakarta.activation-2.0.0.jar
 jakarta.activation-2.0.1.jar
 jakarta.activation-api-1.2.2.jar
diff --git a/pom.xml b/pom.xml
index 9b2ba30cc..4aac2b951 100644
--- a/pom.xml
+++ b/pom.xml
@@ -89,6 +89,7 @@
         <fabric8.version>5.6.0</fabric8.version>
         <revision>1.7.0</revision>
         <groovy.version>4.0.25</groovy.version>
+        <jackson.version>2.15.2</jackson.version>
         <netty.version>4.1.137.Final</netty.version>
         <snakeyaml.version>2.2</snakeyaml.version>
         <spring-boot.version>2.5.15</spring-boot.version>
@@ -128,6 +129,14 @@
 
     <dependencyManagement>
         <dependencies>
+            <!-- Keep YAML, JSON and Fabric8 on one compatible Jackson API. -->
+            <dependency>
+                <groupId>com.fasterxml.jackson</groupId>
+                <artifactId>jackson-bom</artifactId>
+                <version>${jackson.version}</version>
+                <type>pom</type>
+                <scope>import</scope>
+            </dependency>
             <dependency>
                 <groupId>org.apache.groovy</groupId>
                 <artifactId>groovy-bom</artifactId>
@@ -160,12 +169,6 @@
                 <artifactId>spring-boot-autoconfigure</artifactId>
                 <version>${spring-boot.version}</version>
             </dependency>
-            <!-- Fabric8's kubeconfig parser must support SnakeYAML 2.x. -->
-            <dependency>
-                <groupId>com.fasterxml.jackson.dataformat</groupId>
-                <artifactId>jackson-dataformat-yaml</artifactId>
-                <version>2.15.2</version>
-            </dependency>
             <dependency>
                 <groupId>org.yaml</groupId>
                 <artifactId>snakeyaml</artifactId>