diff --git a/api/src/main/java/jakarta/data/expression/NavigableExpression.java b/api/src/main/java/jakarta/data/expression/NavigableExpression.java
index 690121b76..c3916100b 100644
--- a/api/src/main/java/jakarta/data/expression/NavigableExpression.java
+++ b/api/src/main/java/jakarta/data/expression/NavigableExpression.java
@@ -25,38 +25,23 @@
 import jakarta.data.metamodel.NumericAttribute;
 import jakarta.data.metamodel.TemporalAttribute;
 import jakarta.data.metamodel.TextAttribute;
-import jakarta.data.spi.expression.path.BooleanPath;
-import jakarta.data.spi.expression.path.ComparablePath;
-import jakarta.data.spi.expression.path.NavigablePath;
-import jakarta.data.spi.expression.path.NumericPath;
-import jakarta.data.spi.expression.path.TemporalPath;
-import jakarta.data.spi.expression.path.TextPath;
 
 public interface NavigableExpression<T, U> {
 
-    default <V> NavigableExpression<T, V> navigate(NavigableAttribute<U, V> attribute) {
-        return NavigablePath.of(this, attribute);
-    }
+    <V> NavigableExpression<T, V> navigate(NavigableAttribute<U, V> attribute);
 
-    default TextExpression<T> navigate(TextAttribute<U> attribute) {
-        return TextPath.of(this, attribute);
-    }
+    TextAttribute<T> navigate(TextAttribute<U> attribute);
 
-    default <C extends Comparable<C>> ComparableExpression<T, C> navigate(ComparableAttribute<U, C> attribute) {
-        return ComparablePath.of(this, attribute);
-    }
+    <C extends Comparable<C>> ComparableAttribute<T, C> navigate(
+            ComparableAttribute<U, C> attribute);
 
-    default BooleanExpression<T> navigate(BooleanAttribute<U> attribute) {
-        return BooleanPath.of(this, attribute);
-    }
+    BooleanAttribute<T> navigate(BooleanAttribute<U> attribute);
 
-    default <N extends Number & Comparable<N>> NumericExpression<T, N> navigate(NumericAttribute<U, N> attribute) {
-        return NumericPath.of(this, attribute);
-    }
+    <N extends Number & Comparable<N>> NumericAttribute<T, N> navigate(
+            NumericAttribute<U, N> attribute);
 
-    default <V extends Temporal & Comparable<? extends Temporal>> TemporalExpression<T, V> navigate(
-            TemporalAttribute<U, V> attribute) {
-        return TemporalPath.of(this, attribute);
-    }
+    <V extends Temporal & Comparable<? extends Temporal>>
+            TemporalAttribute<T, V> navigate(
+                    TemporalAttribute<U, V> attribute);
 
 }
diff --git a/api/src/main/java/jakarta/data/metamodel/NavigableAttribute.java b/api/src/main/java/jakarta/data/metamodel/NavigableAttribute.java
index da7b1bb5d..c4ac4adc3 100644
--- a/api/src/main/java/jakarta/data/metamodel/NavigableAttribute.java
+++ b/api/src/main/java/jakarta/data/metamodel/NavigableAttribute.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2025 Contributors to the Eclipse Foundation
+ * Copyright (c) 2025,2026 Contributors to the Eclipse Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,8 +17,16 @@
  */
 package jakarta.data.metamodel;
 
+import java.time.temporal.Temporal;
+
 import jakarta.data.expression.NavigableExpression;
 import jakarta.data.messages.Messages;
+import jakarta.data.spi.expression.path.BooleanPath;
+import jakarta.data.spi.expression.path.ComparablePath;
+import jakarta.data.spi.expression.path.NavigablePath;
+import jakarta.data.spi.expression.path.NumericPath;
+import jakarta.data.spi.expression.path.TemporalPath;
+import jakarta.data.spi.expression.path.TextPath;
 
 /**
  * <p>Represents an entity attribute that is an embeddable or association to
@@ -33,6 +41,41 @@
 public interface NavigableAttribute<T, U>
         extends Attribute<T>, NavigableExpression<T, U> {
 
+    @Override
+    default BooleanAttribute<T> navigate(BooleanAttribute<U> attribute) {
+        return BooleanPath.of(this, attribute);
+    }
+
+    @Override
+    default <C extends Comparable<C>> ComparableAttribute<T, C> navigate(
+            ComparableAttribute<U, C> attribute) {
+        return ComparablePath.of(this, attribute);
+    }
+
+    @Override
+    default <V> NavigableExpression<T, V> navigate(
+            NavigableAttribute<U, V> attribute) {
+        return NavigablePath.of(this, attribute);
+    }
+
+    @Override
+    default <N extends Number & Comparable<N>> NumericAttribute<T, N> navigate(
+            NumericAttribute<U, N> attribute) {
+        return NumericPath.of(this, attribute);
+    }
+
+    @Override
+    default <V extends Temporal & Comparable<? extends Temporal>>
+            TemporalAttribute<T, V> navigate(
+                    TemporalAttribute<U, V> attribute) {
+        return TemporalPath.of(this, attribute);
+    }
+
+    @Override
+    default TextAttribute<T> navigate(TextAttribute<U> attribute) {
+        return TextPath.of(this, attribute);
+    }
+
     @Override
     Class<U> type();
 
diff --git a/api/src/main/java/jakarta/data/spi/expression/path/BooleanPath.java b/api/src/main/java/jakarta/data/spi/expression/path/BooleanPath.java
index 7f358c6ec..7e7c7532f 100644
--- a/api/src/main/java/jakarta/data/spi/expression/path/BooleanPath.java
+++ b/api/src/main/java/jakarta/data/spi/expression/path/BooleanPath.java
@@ -17,17 +17,17 @@
  */
 package jakarta.data.spi.expression.path;
 
-import jakarta.data.expression.BooleanExpression;
-import jakarta.data.expression.NavigableExpression;
 import jakarta.data.metamodel.BooleanAttribute;
+import jakarta.data.metamodel.NavigableAttribute;
 
 public interface BooleanPath<T, U>
         extends Path<T, U>,
-                BooleanExpression<T> {
+                BooleanAttribute<T> {
 
-    static <T, U> BooleanPath<T, U> of(NavigableExpression<T, U> expression,
+    static <T, U> BooleanPath<T, U> of(NavigableAttribute<T, U> expression,
                                        BooleanAttribute<U> attribute) {
 
-        return new BooleanPathRecord<>(expression, attribute);
+        String name = expression.name() + '.' + attribute.name();
+        return new BooleanPathRecord<>(name, expression, attribute);
     }
 }
diff --git a/api/src/main/java/jakarta/data/spi/expression/path/BooleanPathRecord.java b/api/src/main/java/jakarta/data/spi/expression/path/BooleanPathRecord.java
index 6cec149fb..d48f48842 100644
--- a/api/src/main/java/jakarta/data/spi/expression/path/BooleanPathRecord.java
+++ b/api/src/main/java/jakarta/data/spi/expression/path/BooleanPathRecord.java
@@ -17,11 +17,12 @@
  */
 package jakarta.data.spi.expression.path;
 
-import jakarta.data.expression.NavigableExpression;
 import jakarta.data.messages.Messages;
 import jakarta.data.metamodel.BooleanAttribute;
+import jakarta.data.metamodel.NavigableAttribute;
 
-record BooleanPathRecord<T, U>(NavigableExpression<T, U> expression,
+record BooleanPathRecord<T, U>(String name,
+                               NavigableAttribute<T, U> expression,
                                BooleanAttribute<U> attribute)
         implements BooleanPath<T, U> {
 
@@ -30,13 +31,19 @@ record BooleanPathRecord<T, U>(NavigableExpression<T, U> expression,
         Messages.requireNonNull(attribute, "attribute");
     }
 
+    @Override
+    public Class<T> declaringType() {
+        return expression.declaringType();
+    }
+
     @Override
     public String toString() {
-        String expr = expression.toString();
-        String attrName = attribute.name();
-        StringBuilder path =
-                new StringBuilder(expr.length() + 1 + attrName.length());
-        path.append(expr).append('.').append(attrName);
-        return path.toString();
+        return expression + "." + attribute.name();
     }
+
+    @Override
+    public Class<Boolean> type() {
+        return attribute.type();
+    }
+
 }
diff --git a/api/src/main/java/jakarta/data/spi/expression/path/ComparablePath.java b/api/src/main/java/jakarta/data/spi/expression/path/ComparablePath.java
index be1c4a4c0..2569c7cbe 100644
--- a/api/src/main/java/jakarta/data/spi/expression/path/ComparablePath.java
+++ b/api/src/main/java/jakarta/data/spi/expression/path/ComparablePath.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2025 Contributors to the Eclipse Foundation
+ * Copyright (c) 2025,2026 Contributors to the Eclipse Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,14 +17,15 @@
  */
 package jakarta.data.spi.expression.path;
 
-import jakarta.data.expression.ComparableExpression;
-import jakarta.data.expression.NavigableExpression;
 import jakarta.data.metamodel.ComparableAttribute;
+import jakarta.data.metamodel.NavigableAttribute;
 
 public interface ComparablePath<T, U, C extends Comparable<?>>
-        extends Path<T, U>, ComparableExpression<T, C> {
-    static <T, U, C extends Comparable<C>> ComparablePath<T, U, C>
-    of(NavigableExpression<T, U> expression, ComparableAttribute<U, C> attribute) {
-        return new ComparablePathRecord<>(expression, attribute);
+        extends Path<T, U>, ComparableAttribute<T, C> {
+    static <T, U, C extends Comparable<C>> ComparablePath<T, U, C> of(
+            NavigableAttribute<T, U> expression,
+            ComparableAttribute<U, C> attribute) {
+        String name = expression.name() + '.' + attribute.name();
+        return new ComparablePathRecord<>(name, expression, attribute);
     }
 }
diff --git a/api/src/main/java/jakarta/data/spi/expression/path/ComparablePathRecord.java b/api/src/main/java/jakarta/data/spi/expression/path/ComparablePathRecord.java
index 63c8679f5..0968ae8ae 100644
--- a/api/src/main/java/jakarta/data/spi/expression/path/ComparablePathRecord.java
+++ b/api/src/main/java/jakarta/data/spi/expression/path/ComparablePathRecord.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2025 Contributors to the Eclipse Foundation
+ * Copyright (c) 2025,2026 Contributors to the Eclipse Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,13 +17,14 @@
  */
 package jakarta.data.spi.expression.path;
 
-import jakarta.data.expression.NavigableExpression;
 import jakarta.data.messages.Messages;
 import jakarta.data.metamodel.ComparableAttribute;
+import jakarta.data.metamodel.NavigableAttribute;
 
-record ComparablePathRecord<T, U, C extends Comparable<?>>
-        (NavigableExpression<T, U> expression,
-         ComparableAttribute<U, C> attribute)
+record ComparablePathRecord<T, U, C extends Comparable<?>>(
+        String name,
+        NavigableAttribute<T, U> expression,
+        ComparableAttribute<U, C> attribute)
         implements ComparablePath<T, U, C> {
 
     ComparablePathRecord {
@@ -32,7 +33,12 @@ record ComparablePathRecord<T, U, C extends Comparable<?>>
     }
 
     @Override
-    public Class<? extends C> type() {
+    public Class<T> declaringType() {
+        return expression.declaringType();
+    }
+
+    @Override
+    public Class<C> type() {
         return attribute.type();
     }
 
diff --git a/api/src/main/java/jakarta/data/spi/expression/path/NavigablePath.java b/api/src/main/java/jakarta/data/spi/expression/path/NavigablePath.java
index a6511087e..12ed839ff 100644
--- a/api/src/main/java/jakarta/data/spi/expression/path/NavigablePath.java
+++ b/api/src/main/java/jakarta/data/spi/expression/path/NavigablePath.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2025 Contributors to the Eclipse Foundation
+ * Copyright (c) 2025,2026 Contributors to the Eclipse Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -22,8 +22,10 @@
 
 public interface NavigablePath<T, U, V>
         extends Path<T, U>, NavigableExpression<T, V> {
-    static <T, U, V> NavigablePath<T, U, V> of(NavigableExpression<T, U> expression,
-                                               NavigableAttribute<U, V> attribute) {
-        return new NavigablePathRecord<>(expression, attribute);
+    static <T, U, V> NavigablePath<T, U, V> of(
+            NavigableAttribute<T, U> expression,
+            NavigableAttribute<U, V> attribute) {
+        String name = expression.name() + '.' + attribute.name();
+        return new NavigablePathRecord<>(name, expression, attribute);
     }
 }
diff --git a/api/src/main/java/jakarta/data/spi/expression/path/NavigablePathRecord.java b/api/src/main/java/jakarta/data/spi/expression/path/NavigablePathRecord.java
index b1cc3d45e..08c79b23c 100644
--- a/api/src/main/java/jakarta/data/spi/expression/path/NavigablePathRecord.java
+++ b/api/src/main/java/jakarta/data/spi/expression/path/NavigablePathRecord.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2025 Contributors to the Eclipse Foundation
+ * Copyright (c) 2025,2026 Contributors to the Eclipse Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,10 +21,11 @@
 import jakarta.data.messages.Messages;
 import jakarta.data.metamodel.NavigableAttribute;
 
-record NavigablePathRecord<T, U, V>
-        (NavigableExpression<T, U> expression,
-         NavigableAttribute<U, V> attribute)
-        implements NavigablePath<T, U, V> {
+record NavigablePathRecord<T, U, V>(
+        String name,
+        NavigableExpression<T, U> expression,
+        NavigableAttribute<U, V> attribute)
+        implements NavigableAttribute<T, V>, NavigablePath<T, U, V> {
 
     NavigablePathRecord {
         Messages.requireNonNull(expression, "expression");
@@ -35,4 +36,9 @@ record NavigablePathRecord<T, U, V>
     public String toString() {
         return expression + "." + attribute.name();
     }
+
+    @Override
+    public Class<V> type() {
+        return attribute.type();
+    }
 }
diff --git a/api/src/main/java/jakarta/data/spi/expression/path/NumericPath.java b/api/src/main/java/jakarta/data/spi/expression/path/NumericPath.java
index f4291534b..ee1a98b93 100644
--- a/api/src/main/java/jakarta/data/spi/expression/path/NumericPath.java
+++ b/api/src/main/java/jakarta/data/spi/expression/path/NumericPath.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2025 Contributors to the Eclipse Foundation
+ * Copyright (c) 2025,2026 Contributors to the Eclipse Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,14 +17,15 @@
  */
 package jakarta.data.spi.expression.path;
 
-import jakarta.data.expression.NavigableExpression;
-import jakarta.data.expression.NumericExpression;
+import jakarta.data.metamodel.NavigableAttribute;
 import jakarta.data.metamodel.NumericAttribute;
 
 public interface NumericPath<T, U, N extends Number & Comparable<N>>
-        extends Path<T, U>, NumericExpression<T, N> {
-    static <T, U, N extends Number & Comparable<N>> NumericPath<T, U, N>
-    of(NavigableExpression<T, U> expression, NumericAttribute<U, N> attribute) {
-        return new NumericPathRecord<>(expression, attribute);
+        extends Path<T, U>, NumericAttribute<T, N> {
+    static <T, U, N extends Number & Comparable<N>> NumericPath<T, U, N> of(
+            NavigableAttribute<T, U> expression,
+            NumericAttribute<U, N> attribute) {
+        String name = expression.name() + '.' + attribute.name();
+        return new NumericPathRecord<>(name, expression, attribute);
     }
 }
diff --git a/api/src/main/java/jakarta/data/spi/expression/path/NumericPathRecord.java b/api/src/main/java/jakarta/data/spi/expression/path/NumericPathRecord.java
index 259e15095..666bc1530 100644
--- a/api/src/main/java/jakarta/data/spi/expression/path/NumericPathRecord.java
+++ b/api/src/main/java/jakarta/data/spi/expression/path/NumericPathRecord.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2025 Contributors to the Eclipse Foundation
+ * Copyright (c) 2025,2026 Contributors to the Eclipse Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,12 +17,14 @@
  */
 package jakarta.data.spi.expression.path;
 
-import jakarta.data.expression.NavigableExpression;
 import jakarta.data.messages.Messages;
+import jakarta.data.metamodel.NavigableAttribute;
 import jakarta.data.metamodel.NumericAttribute;
 
-record NumericPathRecord<T, U, N extends Number & Comparable<N>>
-        (NavigableExpression<T, U> expression, NumericAttribute<U, N> attribute)
+record NumericPathRecord<T, U, N extends Number & Comparable<N>>(
+        String name,
+        NavigableAttribute<T, U> expression,
+        NumericAttribute<U, N> attribute)
         implements NumericPath<T, U, N> {
 
     NumericPathRecord {
@@ -31,7 +33,12 @@ record NumericPathRecord<T, U, N extends Number & Comparable<N>>
     }
 
     @Override
-    public Class<? extends N> type() {
+    public Class<T> declaringType() {
+        return expression.declaringType();
+    }
+
+    @Override
+    public Class<N> type() {
         return attribute.type();
     }
 
diff --git a/api/src/main/java/jakarta/data/spi/expression/path/TemporalPath.java b/api/src/main/java/jakarta/data/spi/expression/path/TemporalPath.java
index 9ca12b0db..1619d61be 100644
--- a/api/src/main/java/jakarta/data/spi/expression/path/TemporalPath.java
+++ b/api/src/main/java/jakarta/data/spi/expression/path/TemporalPath.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2025 Contributors to the Eclipse Foundation
+ * Copyright (c) 2025,2026 Contributors to the Eclipse Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,17 +19,18 @@
 
 import java.time.temporal.Temporal;
 
-import jakarta.data.expression.NavigableExpression;
-import jakarta.data.expression.TemporalExpression;
+import jakarta.data.metamodel.NavigableAttribute;
 import jakarta.data.metamodel.TemporalAttribute;
 
 public interface TemporalPath<T, U, V extends Temporal & Comparable<? extends Temporal>>
-        extends Path<T, U>, TemporalExpression<T, V> {
+        extends Path<T, U>, TemporalAttribute<T, V> {
 
-    static <T, U, V extends Temporal & Comparable<? extends Temporal>> TemporalPath<T, U, V> of(
-            NavigableExpression<T, U> expression,
-            TemporalAttribute<U, V> attribute) {
+    static <T, U, V extends Temporal & Comparable<? extends Temporal>>
+            TemporalPath<T, U, V> of(
+                    NavigableAttribute<T, U> expression,
+                    TemporalAttribute<U, V> attribute) {
 
-        return new TemporalPathRecord<>(expression, attribute);
+        String name = expression.name() + '.' + attribute.name();
+        return new TemporalPathRecord<>(name, expression, attribute);
     }
 }
diff --git a/api/src/main/java/jakarta/data/spi/expression/path/TemporalPathRecord.java b/api/src/main/java/jakarta/data/spi/expression/path/TemporalPathRecord.java
index 988975f16..ff9e68586 100644
--- a/api/src/main/java/jakarta/data/spi/expression/path/TemporalPathRecord.java
+++ b/api/src/main/java/jakarta/data/spi/expression/path/TemporalPathRecord.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2025 Contributors to the Eclipse Foundation
+ * Copyright (c) 2025,2026 Contributors to the Eclipse Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,13 +19,16 @@
 
 import java.time.temporal.Temporal;
 
-import jakarta.data.expression.NavigableExpression;
 import jakarta.data.messages.Messages;
+import jakarta.data.metamodel.NavigableAttribute;
 import jakarta.data.metamodel.TemporalAttribute;
 
-record TemporalPathRecord<T, U, V extends Temporal & Comparable<? extends Temporal>>(
-        NavigableExpression<T, U> expression,
-        TemporalAttribute<U, V> attribute) implements TemporalPath<T, U, V> {
+record TemporalPathRecord<T, U, V extends Temporal &
+                          Comparable<? extends Temporal>>(
+        String name,
+        NavigableAttribute<T, U> expression,
+        TemporalAttribute<U, V> attribute)
+        implements TemporalPath<T, U, V> {
 
     TemporalPathRecord {
         Messages.requireNonNull(expression, "expression");
@@ -33,8 +36,13 @@ record TemporalPathRecord<T, U, V extends Temporal & Comparable<? extends Tempor
     }
 
     @Override
-    public Class<? extends V> type() {
-        return attribute().type();
+    public Class<T> declaringType() {
+        return expression.declaringType();
+    }
+
+    @Override
+    public Class<V> type() {
+        return attribute.type();
     }
 
     @Override
diff --git a/api/src/main/java/jakarta/data/spi/expression/path/TextPath.java b/api/src/main/java/jakarta/data/spi/expression/path/TextPath.java
index da5778844..45cf86cba 100644
--- a/api/src/main/java/jakarta/data/spi/expression/path/TextPath.java
+++ b/api/src/main/java/jakarta/data/spi/expression/path/TextPath.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2025 Contributors to the Eclipse Foundation
+ * Copyright (c) 2025,2026 Contributors to the Eclipse Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,13 +17,14 @@
  */
 package jakarta.data.spi.expression.path;
 
-import jakarta.data.expression.NavigableExpression;
-import jakarta.data.expression.TextExpression;
+import jakarta.data.metamodel.NavigableAttribute;
 import jakarta.data.metamodel.TextAttribute;
 
 public interface TextPath<T, U>
-        extends Path<T, U>, TextExpression<T> {
-    static <T, U> TextPath<T, U> of(NavigableExpression<T, U> expression, TextAttribute<U> attribute) {
-        return new TextPathRecord<>(expression, attribute);
+        extends Path<T, U>, TextAttribute<T> {
+    static <T, U> TextPath<T, U> of(NavigableAttribute<T, U> expression,
+                                    TextAttribute<U> attribute) {
+        String name = expression.name() + '.' + attribute.name();
+        return new TextPathRecord<>(name, expression, attribute);
     }
 }
diff --git a/api/src/main/java/jakarta/data/spi/expression/path/TextPathRecord.java b/api/src/main/java/jakarta/data/spi/expression/path/TextPathRecord.java
index 2d5406fcc..f2c796be8 100644
--- a/api/src/main/java/jakarta/data/spi/expression/path/TextPathRecord.java
+++ b/api/src/main/java/jakarta/data/spi/expression/path/TextPathRecord.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2025 Contributors to the Eclipse Foundation
+ * Copyright (c) 2025,2026 Contributors to the Eclipse Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,12 +17,14 @@
  */
 package jakarta.data.spi.expression.path;
 
-import jakarta.data.expression.NavigableExpression;
 import jakarta.data.messages.Messages;
+import jakarta.data.metamodel.NavigableAttribute;
 import jakarta.data.metamodel.TextAttribute;
 
-record TextPathRecord<T, U>
-        (NavigableExpression<T, U> expression, TextAttribute<U> attribute)
+record TextPathRecord<T, U>(
+        String name,
+        NavigableAttribute<T, U> expression,
+        TextAttribute<U> attribute)
         implements TextPath<T, U> {
 
     TextPathRecord {
@@ -30,6 +32,11 @@ record TextPathRecord<T, U>
         Messages.requireNonNull(attribute, "attribute");
     }
 
+    @Override
+    public Class<T> declaringType() {
+        return expression.declaringType();
+    }
+
     @Override
     public String toString() {
         return expression + "." + attribute.name();
diff --git a/api/src/test/java/jakarta/data/spi/expression/path/ComparablePathTest.java b/api/src/test/java/jakarta/data/spi/expression/path/ComparablePathTest.java
index 209c91800..1585bf173 100644
--- a/api/src/test/java/jakarta/data/spi/expression/path/ComparablePathTest.java
+++ b/api/src/test/java/jakarta/data/spi/expression/path/ComparablePathTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2025 Contributors to the Eclipse Foundation
+ * Copyright (c) 2025,2026 Contributors to the Eclipse Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,7 +21,6 @@
 import jakarta.data.expression.NavigableExpression;
 import jakarta.data.metamodel.ComparableAttribute;
 import jakarta.data.metamodel.NavigableAttribute;
-import jakarta.data.spi.expression.path.ComparablePath;
 
 import org.assertj.core.api.SoftAssertions;
 import org.junit.jupiter.api.DisplayName;
@@ -56,7 +55,7 @@ void shouldCreateComparablePath() {
         NavigableExpression<Author, Publisher> expr = _Author.publisher;
         ComparableAttribute<Publisher, Integer> attr = _Publisher.rating;
 
-        var path = ComparablePath.of(expr, attr);
+        var path = expr.navigate(attr);
 
         SoftAssertions.assertSoftly(soft -> {
             soft.assertThat(path).isNotNull();
diff --git a/api/src/test/java/jakarta/data/spi/expression/path/NavigablePathTest.java b/api/src/test/java/jakarta/data/spi/expression/path/NavigablePathTest.java
index 52d0d1561..4fbfa4cf0 100644
--- a/api/src/test/java/jakarta/data/spi/expression/path/NavigablePathTest.java
+++ b/api/src/test/java/jakarta/data/spi/expression/path/NavigablePathTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2025 Contributors to the Eclipse Foundation
+ * Copyright (c) 2025,2026 Contributors to the Eclipse Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,9 +17,15 @@
  */
 package jakarta.data.spi.expression.path;
 
+import java.time.LocalDate;
+
 import jakarta.data.expression.NavigableExpression;
+import jakarta.data.metamodel.BooleanAttribute;
+import jakarta.data.metamodel.ComparableAttribute;
 import jakarta.data.metamodel.NavigableAttribute;
-import jakarta.data.spi.expression.path.NavigablePath;
+import jakarta.data.metamodel.NumericAttribute;
+import jakarta.data.metamodel.TemporalAttribute;
+import jakarta.data.metamodel.TextAttribute;
 
 import org.assertj.core.api.SoftAssertions;
 import org.junit.jupiter.api.DisplayName;
@@ -30,17 +36,48 @@
  */
 class NavigablePathTest {
 
-    static class Publisher {
+    static enum BusinessType {
+        COMMERCIAL,
+        GOVERNMENT,
+        NONPROFIT
+    }
+
+    static class BusinessInfo {
+        Boolean active;
+        LocalDate founded;
         String name;
+        BusinessType type;
+        int zipcode;
+    }
+
+    static class Publisher {
+        BusinessInfo info;
     }
 
     static class Book {
         Publisher publisher;
     }
 
+    interface _BusinessInfo {
+        BooleanAttribute<BusinessInfo> active =
+                BooleanAttribute.of(BusinessInfo.class, "active", Boolean.class);
+
+        TemporalAttribute<BusinessInfo, LocalDate> founded =
+                TemporalAttribute.of(BusinessInfo.class, "founded", LocalDate.class);
+
+        TextAttribute<BusinessInfo> name =
+                TextAttribute.of(BusinessInfo.class, "name");
+
+        ComparableAttribute<BusinessInfo, BusinessType> type =
+                ComparableAttribute.of(BusinessInfo.class, "type", BusinessType.class);
+
+        NumericAttribute<BusinessInfo, Integer> zipcode =
+                NumericAttribute.of(BusinessInfo.class, "zipcode", int.class);
+    }
+
     interface _Publisher {
-        NavigableAttribute<Publisher, String> name =
-                NavigableAttribute.of(Publisher.class, "name", String.class);
+        NavigableAttribute<Publisher, BusinessInfo> info =
+                NavigableAttribute.of(Publisher.class, "info", BusinessInfo.class);
     }
 
     interface _Book {
@@ -49,18 +86,117 @@ interface _Book {
     }
 
     @Test
-    @DisplayName("should create NavigablePath from expression and attribute")
+    @DisplayName("should create BooleanPath from path and attribute")
+    void shouldCreateBooleanPath() {
+        BooleanAttribute<Book> publisherInfoActive =
+                _Book.publisher.navigate(_Publisher.info)
+                               .navigate(_BusinessInfo.active);
+
+        SoftAssertions.assertSoftly(soft -> {
+            soft.assertThat(publisherInfoActive.name())
+                .isEqualTo("publisher.info.active");
+            soft.assertThat(publisherInfoActive.asc().property())
+                .isEqualTo("publisher.info.active");
+            soft.assertThat(publisherInfoActive.desc().property())
+                .isEqualTo("publisher.info.active");
+            soft.assertThat(publisherInfoActive.toString())
+                .isEqualTo("book.publisher.info.active");
+        });
+    }
+
+    @Test
+    @DisplayName("should create ComparablePath from path and attribute")
+    void shouldCreateComparablePath() {
+        ComparableAttribute<Book, BusinessType> publisherBusinessInfoType =
+                _Book.publisher.navigate(_Publisher.info)
+                               .navigate(_BusinessInfo.type);
+
+        SoftAssertions.assertSoftly(soft -> {
+            soft.assertThat(publisherBusinessInfoType.name())
+                .isEqualTo("publisher.info.type");
+            soft.assertThat(publisherBusinessInfoType.asc().property())
+                .isEqualTo("publisher.info.type");
+            soft.assertThat(publisherBusinessInfoType.desc().property())
+                .isEqualTo("publisher.info.type");
+            soft.assertThat(publisherBusinessInfoType.toString())
+                .isEqualTo("book.publisher.info.type");
+        });
+    }
+
+    @Test
+    @DisplayName("should create NavigablePath from path and attribute")
     void shouldCreateNavigablePath() {
-        NavigableExpression<Book, Publisher> expr = _Book.publisher;
-        NavigableAttribute<Publisher, String> attr = _Publisher.name;
 
-        var path = NavigablePath.of(expr, attr);
+        SoftAssertions.assertSoftly(soft -> {
+            soft.assertThat(_Book.publisher.name())
+                .isEqualTo("publisher");
+            soft.assertThat(_Book.publisher.toString())
+                .isEqualTo("book.publisher");
+        });
+
+        NavigableExpression<Book, BusinessInfo> publisherInfo =
+                _Book.publisher.navigate(_Publisher.info);
+
+        SoftAssertions.assertSoftly(soft -> {
+            soft.assertThat(publisherInfo.toString())
+                .isEqualTo("book.publisher.info");
+        });
+    }
+
+    @Test
+    @DisplayName("should create NumericPath from path and attribute")
+    void shouldCreateNumericPath() {
+        NumericAttribute<Book, Integer> publisherInfoZipcode =
+                _Book.publisher.navigate(_Publisher.info)
+                               .navigate(_BusinessInfo.zipcode);
+
+        SoftAssertions.assertSoftly(soft -> {
+            soft.assertThat(publisherInfoZipcode.name())
+                .isEqualTo("publisher.info.zipcode");
+            soft.assertThat(publisherInfoZipcode.asc().property())
+                .isEqualTo("publisher.info.zipcode");
+            soft.assertThat(publisherInfoZipcode.desc().property())
+                .isEqualTo("publisher.info.zipcode");
+            soft.assertThat(publisherInfoZipcode.toString())
+                .isEqualTo("book.publisher.info.zipcode");
+        });
+    }
+
+    @Test
+    @DisplayName("should create TemporalPath from path and attribute")
+    void shouldCreateTemporalPath() {
+        TemporalAttribute<Book, LocalDate> publisherInfoFounded =
+                _Book.publisher.navigate(_Publisher.info)
+                               .navigate(_BusinessInfo.founded);
+
+        SoftAssertions.assertSoftly(soft -> {
+            soft.assertThat(publisherInfoFounded.name())
+                .isEqualTo("publisher.info.founded");
+            soft.assertThat(publisherInfoFounded.asc().property())
+                .isEqualTo("publisher.info.founded");
+            soft.assertThat(publisherInfoFounded.desc().property())
+                .isEqualTo("publisher.info.founded");
+            soft.assertThat(publisherInfoFounded.toString())
+                .isEqualTo("book.publisher.info.founded");
+        });
+    }
+
+    @Test
+    @DisplayName("should create TextPath from path and attribute")
+    void shouldCreateTextPath() {
+        TextAttribute<Book> publisherInfoName =
+                _Book.publisher.navigate(_Publisher.info)
+                               .navigate(_BusinessInfo.name);
 
         SoftAssertions.assertSoftly(soft -> {
-            soft.assertThat(path).isNotNull();
-            soft.assertThat(path).isInstanceOf(NavigableExpression.class);
-            soft.assertThat(path.toString())
-                .isEqualTo("book.publisher.name");
+            soft.assertThat(publisherInfoName.name())
+                .isEqualTo("publisher.info.name");
+            soft.assertThat(publisherInfoName.asc().property())
+                .isEqualTo("publisher.info.name");
+            soft.assertThat(publisherInfoName.descIgnoreCase().property())
+                .isEqualTo("publisher.info.name");
+            soft.assertThat(publisherInfoName.toString())
+                .isEqualTo("book.publisher.info.name");
         });
     }
 }