diff --git a/src/generated/generated_temporal_udfs.cpp b/src/generated/generated_temporal_udfs.cpp
index 35f098cb..56efc60e 100644
--- a/src/generated/generated_temporal_udfs.cpp
+++ b/src/generated/generated_temporal_udfs.cpp
@@ -16,12 +16,15 @@
 #include "h3/th3index.hpp"
 #include "quadbin/tquadbin.hpp"
 #include "json/tjsonb.hpp"
+#include "pointcloud/tpcpoint.hpp"
+#include "pointcloud/tpcpatch.hpp"
 #include "spatial/spatial_types.hpp"
 #include "geo_util.hpp"
 #include "meos_internal.h"
 #include "meos_geo.h"
 #include "meos_internal_geo.h"
 #include "meos_json.h"
+#include "meos_pointcloud.h"
 #include "time_util.hpp"
 #include "mobilityduck/meos_exec_serial.hpp"
 #include "duckdb/function/scalar_function.hpp"
@@ -142,6 +145,38 @@ inline Jsonb *BlobToJsonb(string_t blob) {
     memcpy(copy, blob.GetData(), sz);
     return reinterpret_cast<Jsonb *>(copy);
 }
+// Self-contained blob<->Pcpoint/Pcpatch marshalling. Both are varlena (vl_len_
+// header) -> VARSIZE out; the stored BLOB is the raw bytes (mirror Cbuffer).
+inline string_t PcpointToBlob(Vector &result, Pcpoint *pt) {
+    string_t out = StringVector::AddStringOrBlob(result, (const char *)pt, VARSIZE(pt));
+    free(pt);
+    return out;
+}
+inline string_t PcpointToBlobN(Vector &result, Pcpoint *pt, ValidityMask &mask, idx_t idx) {
+    if (!pt) { mask.SetInvalid(idx); return string_t(); }
+    return PcpointToBlob(result, pt);
+}
+inline Pcpoint *BlobToPcpoint(string_t blob) {
+    size_t sz = blob.GetSize();
+    uint8_t *copy = (uint8_t *)malloc(sz);
+    memcpy(copy, blob.GetData(), sz);
+    return reinterpret_cast<Pcpoint *>(copy);
+}
+inline string_t PcpatchToBlob(Vector &result, Pcpatch *pa) {
+    string_t out = StringVector::AddStringOrBlob(result, (const char *)pa, VARSIZE(pa));
+    free(pa);
+    return out;
+}
+inline string_t PcpatchToBlobN(Vector &result, Pcpatch *pa, ValidityMask &mask, idx_t idx) {
+    if (!pa) { mask.SetInvalid(idx); return string_t(); }
+    return PcpatchToBlob(result, pa);
+}
+inline Pcpatch *BlobToPcpatch(string_t blob) {
+    size_t sz = blob.GetSize();
+    uint8_t *copy = (uint8_t *)malloc(sz);
+    memcpy(copy, blob.GetData(), sz);
+    return reinterpret_cast<Pcpatch *>(copy);
+}
 // Self-contained blob<->STBox/TBox marshalling (FIXED-size structs -> sizeof).
 inline string_t StboxToBlob(Vector &result, STBox *b) {
     string_t out = StringVector::AddStringOrBlob(result, (const char *)b, sizeof(STBox));
@@ -5680,6 +5715,102 @@ static void Gen_tjsonb_minus_value(DataChunk &args, ExpressionState &, Vector &r
 }
 
 
+// ===== @ingroup meos_pointcloud_accessor =====
+static void Gen_tpcpoint_start_value(DataChunk &args, ExpressionState &, Vector &result) {
+    EnsureMeosThreadInitialized();
+    UnaryExecutor::ExecuteWithNulls<string_t, string_t>(args.data[0], result, args.size(),
+        [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t {
+            Temporal *t = BlobToTemporal(in);
+            Pcpoint * r = tpcpoint_start_value(t);
+            free(t);
+            return PcpointToBlobN(result, r, mask, idx);
+        });
+}
+
+static void Gen_tpcpoint_end_value(DataChunk &args, ExpressionState &, Vector &result) {
+    EnsureMeosThreadInitialized();
+    UnaryExecutor::ExecuteWithNulls<string_t, string_t>(args.data[0], result, args.size(),
+        [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t {
+            Temporal *t = BlobToTemporal(in);
+            Pcpoint * r = tpcpoint_end_value(t);
+            free(t);
+            return PcpointToBlobN(result, r, mask, idx);
+        });
+}
+
+static void Gen_tpcpatch_start_value(DataChunk &args, ExpressionState &, Vector &result) {
+    EnsureMeosThreadInitialized();
+    UnaryExecutor::ExecuteWithNulls<string_t, string_t>(args.data[0], result, args.size(),
+        [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t {
+            Temporal *t = BlobToTemporal(in);
+            Pcpatch * r = tpcpatch_start_value(t);
+            free(t);
+            return PcpatchToBlobN(result, r, mask, idx);
+        });
+}
+
+static void Gen_tpcpatch_end_value(DataChunk &args, ExpressionState &, Vector &result) {
+    EnsureMeosThreadInitialized();
+    UnaryExecutor::ExecuteWithNulls<string_t, string_t>(args.data[0], result, args.size(),
+        [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t {
+            Temporal *t = BlobToTemporal(in);
+            Pcpatch * r = tpcpatch_end_value(t);
+            free(t);
+            return PcpatchToBlobN(result, r, mask, idx);
+        });
+}
+
+
+// ===== @ingroup meos_pointcloud_restrict =====
+static void Gen_tpcpoint_at_value(DataChunk &args, ExpressionState &, Vector &result) {
+    EnsureMeosThreadInitialized();
+    BinaryExecutor::ExecuteWithNulls<string_t, string_t, string_t>(args.data[0], args.data[1], result, args.size(),
+        [&](string_t in, string_t a2, ValidityMask &mask, idx_t idx) -> string_t {
+            Temporal *t = BlobToTemporal(in);
+            Pcpoint *a2p = BlobToPcpoint(a2);
+            Temporal *r = tpcpoint_at_value(t, a2p);
+            free(a2p); free(t);
+            return TemporalToBlobN(result, r, mask, idx);
+        });
+}
+
+static void Gen_tpcpoint_minus_value(DataChunk &args, ExpressionState &, Vector &result) {
+    EnsureMeosThreadInitialized();
+    BinaryExecutor::ExecuteWithNulls<string_t, string_t, string_t>(args.data[0], args.data[1], result, args.size(),
+        [&](string_t in, string_t a2, ValidityMask &mask, idx_t idx) -> string_t {
+            Temporal *t = BlobToTemporal(in);
+            Pcpoint *a2p = BlobToPcpoint(a2);
+            Temporal *r = tpcpoint_minus_value(t, a2p);
+            free(a2p); free(t);
+            return TemporalToBlobN(result, r, mask, idx);
+        });
+}
+
+static void Gen_tpcpatch_at_value(DataChunk &args, ExpressionState &, Vector &result) {
+    EnsureMeosThreadInitialized();
+    BinaryExecutor::ExecuteWithNulls<string_t, string_t, string_t>(args.data[0], args.data[1], result, args.size(),
+        [&](string_t in, string_t a2, ValidityMask &mask, idx_t idx) -> string_t {
+            Temporal *t = BlobToTemporal(in);
+            Pcpatch *a2p = BlobToPcpatch(a2);
+            Temporal *r = tpcpatch_at_value(t, a2p);
+            free(a2p); free(t);
+            return TemporalToBlobN(result, r, mask, idx);
+        });
+}
+
+static void Gen_tpcpatch_minus_value(DataChunk &args, ExpressionState &, Vector &result) {
+    EnsureMeosThreadInitialized();
+    BinaryExecutor::ExecuteWithNulls<string_t, string_t, string_t>(args.data[0], args.data[1], result, args.size(),
+        [&](string_t in, string_t a2, ValidityMask &mask, idx_t idx) -> string_t {
+            Temporal *t = BlobToTemporal(in);
+            Pcpatch *a2p = BlobToPcpatch(a2);
+            Temporal *r = tpcpatch_minus_value(t, a2p);
+            free(a2p); free(t);
+            return TemporalToBlobN(result, r, mask, idx);
+        });
+}
+
+
 // ===== @ingroup meos_quadbin_accessor =====
 static void Gen_tquadbin_start_value(DataChunk &args, ExpressionState &, Vector &result) {
     EnsureMeosThreadInitialized();
@@ -16939,6 +17070,20 @@ static void RegisterGenerated_meos_json_restrict(ExtensionLoader &loader) {
     RegisterSerializedScalarFunction(loader, ScalarFunction("minusValue", {TJsonbTypes::tjsonb(), TJsonbTypes::jsonb()}, TJsonbTypes::tjsonb(), Gen_tjsonb_minus_value));
 }
 
+static void RegisterGenerated_meos_pointcloud_accessor(ExtensionLoader &loader) {
+    RegisterSerializedScalarFunction(loader, ScalarFunction("startValue", {TPcpointTypes::tpcpoint()}, TPcpointTypes::pcpoint(), Gen_tpcpoint_start_value));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("endValue", {TPcpointTypes::tpcpoint()}, TPcpointTypes::pcpoint(), Gen_tpcpoint_end_value));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("startValue", {TPcpatchTypes::tpcpatch()}, TPcpatchTypes::pcpatch(), Gen_tpcpatch_start_value));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("endValue", {TPcpatchTypes::tpcpatch()}, TPcpatchTypes::pcpatch(), Gen_tpcpatch_end_value));
+}
+
+static void RegisterGenerated_meos_pointcloud_restrict(ExtensionLoader &loader) {
+    RegisterSerializedScalarFunction(loader, ScalarFunction("atValue", {TPcpointTypes::tpcpoint(), TPcpointTypes::pcpoint()}, TPcpointTypes::tpcpoint(), Gen_tpcpoint_at_value));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("minusValue", {TPcpointTypes::tpcpoint(), TPcpointTypes::pcpoint()}, TPcpointTypes::tpcpoint(), Gen_tpcpoint_minus_value));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("atValue", {TPcpatchTypes::tpcpatch(), TPcpatchTypes::pcpatch()}, TPcpatchTypes::tpcpatch(), Gen_tpcpatch_at_value));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("minusValue", {TPcpatchTypes::tpcpatch(), TPcpatchTypes::pcpatch()}, TPcpatchTypes::tpcpatch(), Gen_tpcpatch_minus_value));
+}
+
 static void RegisterGenerated_meos_quadbin_accessor(ExtensionLoader &loader) {
     RegisterSerializedScalarFunction(loader, ScalarFunction("startValue", {QuadbinTypes::tquadbin()}, QuadbinTypes::quadbin(), Gen_tquadbin_start_value));
     RegisterSerializedScalarFunction(loader, ScalarFunction("endValue", {QuadbinTypes::tquadbin()}, QuadbinTypes::quadbin(), Gen_tquadbin_end_value));
@@ -17724,6 +17869,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) {
     RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {H3indexTypes::th3index(), LogicalType::BOOLEAN}, LogicalType::INTERVAL, Gen_temporal_duration));
     RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {QuadbinTypes::tquadbin(), LogicalType::BOOLEAN}, LogicalType::INTERVAL, Gen_temporal_duration));
     RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {TJsonbTypes::tjsonb(), LogicalType::BOOLEAN}, LogicalType::INTERVAL, Gen_temporal_duration));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {TPcpointTypes::tpcpoint(), LogicalType::BOOLEAN}, LogicalType::INTERVAL, Gen_temporal_duration));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {TPcpatchTypes::tpcpatch(), LogicalType::BOOLEAN}, LogicalType::INTERVAL, Gen_temporal_duration));
     RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {TemporalTypes::tint()}, LogicalType::INTERVAL, Gen_temporal_duration_d));
     RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {TemporalTypes::tbigint()}, LogicalType::INTERVAL, Gen_temporal_duration_d));
     RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {TemporalTypes::tbool()}, LogicalType::INTERVAL, Gen_temporal_duration_d));
@@ -17737,6 +17884,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) {
     RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {H3indexTypes::th3index()}, LogicalType::INTERVAL, Gen_temporal_duration_d));
     RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {QuadbinTypes::tquadbin()}, LogicalType::INTERVAL, Gen_temporal_duration_d));
     RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {TJsonbTypes::tjsonb()}, LogicalType::INTERVAL, Gen_temporal_duration_d));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {TPcpointTypes::tpcpoint()}, LogicalType::INTERVAL, Gen_temporal_duration_d));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {TPcpatchTypes::tpcpatch()}, LogicalType::INTERVAL, Gen_temporal_duration_d));
     RegisterSerializedScalarFunction(loader, ScalarFunction("endInstant", {TemporalTypes::tint()}, TemporalTypes::tint(), Gen_temporal_end_instant));
     RegisterSerializedScalarFunction(loader, ScalarFunction("endInstant", {TemporalTypes::tbigint()}, TemporalTypes::tbigint(), Gen_temporal_end_instant));
     RegisterSerializedScalarFunction(loader, ScalarFunction("endInstant", {TemporalTypes::tbool()}, TemporalTypes::tbool(), Gen_temporal_end_instant));
@@ -17750,6 +17899,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) {
     RegisterSerializedScalarFunction(loader, ScalarFunction("endInstant", {H3indexTypes::th3index()}, H3indexTypes::th3index(), Gen_temporal_end_instant));
     RegisterSerializedScalarFunction(loader, ScalarFunction("endInstant", {QuadbinTypes::tquadbin()}, QuadbinTypes::tquadbin(), Gen_temporal_end_instant));
     RegisterSerializedScalarFunction(loader, ScalarFunction("endInstant", {TJsonbTypes::tjsonb()}, TJsonbTypes::tjsonb(), Gen_temporal_end_instant));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("endInstant", {TPcpointTypes::tpcpoint()}, TPcpointTypes::tpcpoint(), Gen_temporal_end_instant));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("endInstant", {TPcpatchTypes::tpcpatch()}, TPcpatchTypes::tpcpatch(), Gen_temporal_end_instant));
     RegisterSerializedScalarFunction(loader, ScalarFunction("endSequence", {TemporalTypes::tint()}, TemporalTypes::tint(), Gen_temporal_end_sequence));
     RegisterSerializedScalarFunction(loader, ScalarFunction("endSequence", {TemporalTypes::tbigint()}, TemporalTypes::tbigint(), Gen_temporal_end_sequence));
     RegisterSerializedScalarFunction(loader, ScalarFunction("endSequence", {TemporalTypes::tbool()}, TemporalTypes::tbool(), Gen_temporal_end_sequence));
@@ -17763,6 +17914,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) {
     RegisterSerializedScalarFunction(loader, ScalarFunction("endSequence", {H3indexTypes::th3index()}, H3indexTypes::th3index(), Gen_temporal_end_sequence));
     RegisterSerializedScalarFunction(loader, ScalarFunction("endSequence", {QuadbinTypes::tquadbin()}, QuadbinTypes::tquadbin(), Gen_temporal_end_sequence));
     RegisterSerializedScalarFunction(loader, ScalarFunction("endSequence", {TJsonbTypes::tjsonb()}, TJsonbTypes::tjsonb(), Gen_temporal_end_sequence));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("endSequence", {TPcpointTypes::tpcpoint()}, TPcpointTypes::tpcpoint(), Gen_temporal_end_sequence));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("endSequence", {TPcpatchTypes::tpcpatch()}, TPcpatchTypes::tpcpatch(), Gen_temporal_end_sequence));
     RegisterSerializedScalarFunction(loader, ScalarFunction("endTimestamp", {TemporalTypes::tint()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_end_timestamptz));
     RegisterSerializedScalarFunction(loader, ScalarFunction("endTimestamp", {TemporalTypes::tbigint()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_end_timestamptz));
     RegisterSerializedScalarFunction(loader, ScalarFunction("endTimestamp", {TemporalTypes::tbool()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_end_timestamptz));
@@ -17776,6 +17929,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) {
     RegisterSerializedScalarFunction(loader, ScalarFunction("endTimestamp", {H3indexTypes::th3index()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_end_timestamptz));
     RegisterSerializedScalarFunction(loader, ScalarFunction("endTimestamp", {QuadbinTypes::tquadbin()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_end_timestamptz));
     RegisterSerializedScalarFunction(loader, ScalarFunction("endTimestamp", {TJsonbTypes::tjsonb()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_end_timestamptz));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("endTimestamp", {TPcpointTypes::tpcpoint()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_end_timestamptz));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("endTimestamp", {TPcpatchTypes::tpcpatch()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_end_timestamptz));
     RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_hash", {TemporalTypes::tint()}, LogicalType::UINTEGER, Gen_temporal_hash));
     RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_hash", {TemporalTypes::tbigint()}, LogicalType::UINTEGER, Gen_temporal_hash));
     RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_hash", {TemporalTypes::tbool()}, LogicalType::UINTEGER, Gen_temporal_hash));
@@ -17789,6 +17944,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) {
     RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_hash", {H3indexTypes::th3index()}, LogicalType::UINTEGER, Gen_temporal_hash));
     RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_hash", {QuadbinTypes::tquadbin()}, LogicalType::UINTEGER, Gen_temporal_hash));
     RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_hash", {TJsonbTypes::tjsonb()}, LogicalType::UINTEGER, Gen_temporal_hash));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_hash", {TPcpointTypes::tpcpoint()}, LogicalType::UINTEGER, Gen_temporal_hash));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_hash", {TPcpatchTypes::tpcpatch()}, LogicalType::UINTEGER, Gen_temporal_hash));
     RegisterSerializedScalarFunction(loader, ScalarFunction("instantN", {TemporalTypes::tint(), LogicalType::INTEGER}, TemporalTypes::tint(), Gen_temporal_instant_n));
     RegisterSerializedScalarFunction(loader, ScalarFunction("instantN", {TemporalTypes::tbigint(), LogicalType::INTEGER}, TemporalTypes::tbigint(), Gen_temporal_instant_n));
     RegisterSerializedScalarFunction(loader, ScalarFunction("instantN", {TemporalTypes::tbool(), LogicalType::INTEGER}, TemporalTypes::tbool(), Gen_temporal_instant_n));
@@ -17802,6 +17959,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) {
     RegisterSerializedScalarFunction(loader, ScalarFunction("instantN", {H3indexTypes::th3index(), LogicalType::INTEGER}, H3indexTypes::th3index(), Gen_temporal_instant_n));
     RegisterSerializedScalarFunction(loader, ScalarFunction("instantN", {QuadbinTypes::tquadbin(), LogicalType::INTEGER}, QuadbinTypes::tquadbin(), Gen_temporal_instant_n));
     RegisterSerializedScalarFunction(loader, ScalarFunction("instantN", {TJsonbTypes::tjsonb(), LogicalType::INTEGER}, TJsonbTypes::tjsonb(), Gen_temporal_instant_n));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("instantN", {TPcpointTypes::tpcpoint(), LogicalType::INTEGER}, TPcpointTypes::tpcpoint(), Gen_temporal_instant_n));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("instantN", {TPcpatchTypes::tpcpatch(), LogicalType::INTEGER}, TPcpatchTypes::tpcpatch(), Gen_temporal_instant_n));
     RegisterSerializedScalarFunction(loader, ScalarFunction("interp", {TemporalTypes::tint()}, LogicalType::VARCHAR, Gen_temporal_interp));
     RegisterSerializedScalarFunction(loader, ScalarFunction("interp", {TemporalTypes::tbigint()}, LogicalType::VARCHAR, Gen_temporal_interp));
     RegisterSerializedScalarFunction(loader, ScalarFunction("interp", {TemporalTypes::tbool()}, LogicalType::VARCHAR, Gen_temporal_interp));
@@ -17815,6 +17974,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) {
     RegisterSerializedScalarFunction(loader, ScalarFunction("interp", {H3indexTypes::th3index()}, LogicalType::VARCHAR, Gen_temporal_interp));
     RegisterSerializedScalarFunction(loader, ScalarFunction("interp", {QuadbinTypes::tquadbin()}, LogicalType::VARCHAR, Gen_temporal_interp));
     RegisterSerializedScalarFunction(loader, ScalarFunction("interp", {TJsonbTypes::tjsonb()}, LogicalType::VARCHAR, Gen_temporal_interp));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("interp", {TPcpointTypes::tpcpoint()}, LogicalType::VARCHAR, Gen_temporal_interp));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("interp", {TPcpatchTypes::tpcpatch()}, LogicalType::VARCHAR, Gen_temporal_interp));
     RegisterSerializedScalarFunction(loader, ScalarFunction("lowerInc", {TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_temporal_lower_inc));
     RegisterSerializedScalarFunction(loader, ScalarFunction("lowerInc", {TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_temporal_lower_inc));
     RegisterSerializedScalarFunction(loader, ScalarFunction("lowerInc", {TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_temporal_lower_inc));
@@ -17828,6 +17989,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) {
     RegisterSerializedScalarFunction(loader, ScalarFunction("lowerInc", {H3indexTypes::th3index()}, LogicalType::BOOLEAN, Gen_temporal_lower_inc));
     RegisterSerializedScalarFunction(loader, ScalarFunction("lowerInc", {QuadbinTypes::tquadbin()}, LogicalType::BOOLEAN, Gen_temporal_lower_inc));
     RegisterSerializedScalarFunction(loader, ScalarFunction("lowerInc", {TJsonbTypes::tjsonb()}, LogicalType::BOOLEAN, Gen_temporal_lower_inc));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("lowerInc", {TPcpointTypes::tpcpoint()}, LogicalType::BOOLEAN, Gen_temporal_lower_inc));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("lowerInc", {TPcpatchTypes::tpcpatch()}, LogicalType::BOOLEAN, Gen_temporal_lower_inc));
     RegisterSerializedScalarFunction(loader, ScalarFunction("maxInstant", {TemporalTypes::tint()}, TemporalTypes::tint(), Gen_temporal_max_instant));
     RegisterSerializedScalarFunction(loader, ScalarFunction("maxInstant", {TemporalTypes::tbigint()}, TemporalTypes::tbigint(), Gen_temporal_max_instant));
     RegisterSerializedScalarFunction(loader, ScalarFunction("maxInstant", {TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_temporal_max_instant));
@@ -17849,6 +18012,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) {
     RegisterSerializedScalarFunction(loader, ScalarFunction("numInstants", {H3indexTypes::th3index()}, LogicalType::INTEGER, Gen_temporal_num_instants));
     RegisterSerializedScalarFunction(loader, ScalarFunction("numInstants", {QuadbinTypes::tquadbin()}, LogicalType::INTEGER, Gen_temporal_num_instants));
     RegisterSerializedScalarFunction(loader, ScalarFunction("numInstants", {TJsonbTypes::tjsonb()}, LogicalType::INTEGER, Gen_temporal_num_instants));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("numInstants", {TPcpointTypes::tpcpoint()}, LogicalType::INTEGER, Gen_temporal_num_instants));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("numInstants", {TPcpatchTypes::tpcpatch()}, LogicalType::INTEGER, Gen_temporal_num_instants));
     RegisterSerializedScalarFunction(loader, ScalarFunction("numSequences", {TemporalTypes::tint()}, LogicalType::INTEGER, Gen_temporal_num_sequences));
     RegisterSerializedScalarFunction(loader, ScalarFunction("numSequences", {TemporalTypes::tbigint()}, LogicalType::INTEGER, Gen_temporal_num_sequences));
     RegisterSerializedScalarFunction(loader, ScalarFunction("numSequences", {TemporalTypes::tbool()}, LogicalType::INTEGER, Gen_temporal_num_sequences));
@@ -17862,6 +18027,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) {
     RegisterSerializedScalarFunction(loader, ScalarFunction("numSequences", {H3indexTypes::th3index()}, LogicalType::INTEGER, Gen_temporal_num_sequences));
     RegisterSerializedScalarFunction(loader, ScalarFunction("numSequences", {QuadbinTypes::tquadbin()}, LogicalType::INTEGER, Gen_temporal_num_sequences));
     RegisterSerializedScalarFunction(loader, ScalarFunction("numSequences", {TJsonbTypes::tjsonb()}, LogicalType::INTEGER, Gen_temporal_num_sequences));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("numSequences", {TPcpointTypes::tpcpoint()}, LogicalType::INTEGER, Gen_temporal_num_sequences));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("numSequences", {TPcpatchTypes::tpcpatch()}, LogicalType::INTEGER, Gen_temporal_num_sequences));
     RegisterSerializedScalarFunction(loader, ScalarFunction("numTimestamps", {TemporalTypes::tint()}, LogicalType::INTEGER, Gen_temporal_num_timestamps));
     RegisterSerializedScalarFunction(loader, ScalarFunction("numTimestamps", {TemporalTypes::tbigint()}, LogicalType::INTEGER, Gen_temporal_num_timestamps));
     RegisterSerializedScalarFunction(loader, ScalarFunction("numTimestamps", {TemporalTypes::tbool()}, LogicalType::INTEGER, Gen_temporal_num_timestamps));
@@ -17875,6 +18042,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) {
     RegisterSerializedScalarFunction(loader, ScalarFunction("numTimestamps", {H3indexTypes::th3index()}, LogicalType::INTEGER, Gen_temporal_num_timestamps));
     RegisterSerializedScalarFunction(loader, ScalarFunction("numTimestamps", {QuadbinTypes::tquadbin()}, LogicalType::INTEGER, Gen_temporal_num_timestamps));
     RegisterSerializedScalarFunction(loader, ScalarFunction("numTimestamps", {TJsonbTypes::tjsonb()}, LogicalType::INTEGER, Gen_temporal_num_timestamps));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("numTimestamps", {TPcpointTypes::tpcpoint()}, LogicalType::INTEGER, Gen_temporal_num_timestamps));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("numTimestamps", {TPcpatchTypes::tpcpatch()}, LogicalType::INTEGER, Gen_temporal_num_timestamps));
     RegisterSerializedScalarFunction(loader, ScalarFunction("sequenceN", {TemporalTypes::tint(), LogicalType::INTEGER}, TemporalTypes::tint(), Gen_temporal_sequence_n));
     RegisterSerializedScalarFunction(loader, ScalarFunction("sequenceN", {TemporalTypes::tbigint(), LogicalType::INTEGER}, TemporalTypes::tbigint(), Gen_temporal_sequence_n));
     RegisterSerializedScalarFunction(loader, ScalarFunction("sequenceN", {TemporalTypes::tbool(), LogicalType::INTEGER}, TemporalTypes::tbool(), Gen_temporal_sequence_n));
@@ -17888,6 +18057,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) {
     RegisterSerializedScalarFunction(loader, ScalarFunction("sequenceN", {H3indexTypes::th3index(), LogicalType::INTEGER}, H3indexTypes::th3index(), Gen_temporal_sequence_n));
     RegisterSerializedScalarFunction(loader, ScalarFunction("sequenceN", {QuadbinTypes::tquadbin(), LogicalType::INTEGER}, QuadbinTypes::tquadbin(), Gen_temporal_sequence_n));
     RegisterSerializedScalarFunction(loader, ScalarFunction("sequenceN", {TJsonbTypes::tjsonb(), LogicalType::INTEGER}, TJsonbTypes::tjsonb(), Gen_temporal_sequence_n));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("sequenceN", {TPcpointTypes::tpcpoint(), LogicalType::INTEGER}, TPcpointTypes::tpcpoint(), Gen_temporal_sequence_n));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("sequenceN", {TPcpatchTypes::tpcpatch(), LogicalType::INTEGER}, TPcpatchTypes::tpcpatch(), Gen_temporal_sequence_n));
     RegisterSerializedScalarFunction(loader, ScalarFunction("startInstant", {TemporalTypes::tint()}, TemporalTypes::tint(), Gen_temporal_start_instant));
     RegisterSerializedScalarFunction(loader, ScalarFunction("startInstant", {TemporalTypes::tbigint()}, TemporalTypes::tbigint(), Gen_temporal_start_instant));
     RegisterSerializedScalarFunction(loader, ScalarFunction("startInstant", {TemporalTypes::tbool()}, TemporalTypes::tbool(), Gen_temporal_start_instant));
@@ -17901,6 +18072,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) {
     RegisterSerializedScalarFunction(loader, ScalarFunction("startInstant", {H3indexTypes::th3index()}, H3indexTypes::th3index(), Gen_temporal_start_instant));
     RegisterSerializedScalarFunction(loader, ScalarFunction("startInstant", {QuadbinTypes::tquadbin()}, QuadbinTypes::tquadbin(), Gen_temporal_start_instant));
     RegisterSerializedScalarFunction(loader, ScalarFunction("startInstant", {TJsonbTypes::tjsonb()}, TJsonbTypes::tjsonb(), Gen_temporal_start_instant));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("startInstant", {TPcpointTypes::tpcpoint()}, TPcpointTypes::tpcpoint(), Gen_temporal_start_instant));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("startInstant", {TPcpatchTypes::tpcpatch()}, TPcpatchTypes::tpcpatch(), Gen_temporal_start_instant));
     RegisterSerializedScalarFunction(loader, ScalarFunction("startSequence", {TemporalTypes::tint()}, TemporalTypes::tint(), Gen_temporal_start_sequence));
     RegisterSerializedScalarFunction(loader, ScalarFunction("startSequence", {TemporalTypes::tbigint()}, TemporalTypes::tbigint(), Gen_temporal_start_sequence));
     RegisterSerializedScalarFunction(loader, ScalarFunction("startSequence", {TemporalTypes::tbool()}, TemporalTypes::tbool(), Gen_temporal_start_sequence));
@@ -17914,6 +18087,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) {
     RegisterSerializedScalarFunction(loader, ScalarFunction("startSequence", {H3indexTypes::th3index()}, H3indexTypes::th3index(), Gen_temporal_start_sequence));
     RegisterSerializedScalarFunction(loader, ScalarFunction("startSequence", {QuadbinTypes::tquadbin()}, QuadbinTypes::tquadbin(), Gen_temporal_start_sequence));
     RegisterSerializedScalarFunction(loader, ScalarFunction("startSequence", {TJsonbTypes::tjsonb()}, TJsonbTypes::tjsonb(), Gen_temporal_start_sequence));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("startSequence", {TPcpointTypes::tpcpoint()}, TPcpointTypes::tpcpoint(), Gen_temporal_start_sequence));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("startSequence", {TPcpatchTypes::tpcpatch()}, TPcpatchTypes::tpcpatch(), Gen_temporal_start_sequence));
     RegisterSerializedScalarFunction(loader, ScalarFunction("startTimestamp", {TemporalTypes::tint()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_start_timestamptz));
     RegisterSerializedScalarFunction(loader, ScalarFunction("startTimestamp", {TemporalTypes::tbigint()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_start_timestamptz));
     RegisterSerializedScalarFunction(loader, ScalarFunction("startTimestamp", {TemporalTypes::tbool()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_start_timestamptz));
@@ -17927,6 +18102,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) {
     RegisterSerializedScalarFunction(loader, ScalarFunction("startTimestamp", {H3indexTypes::th3index()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_start_timestamptz));
     RegisterSerializedScalarFunction(loader, ScalarFunction("startTimestamp", {QuadbinTypes::tquadbin()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_start_timestamptz));
     RegisterSerializedScalarFunction(loader, ScalarFunction("startTimestamp", {TJsonbTypes::tjsonb()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_start_timestamptz));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("startTimestamp", {TPcpointTypes::tpcpoint()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_start_timestamptz));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("startTimestamp", {TPcpatchTypes::tpcpatch()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_start_timestamptz));
     RegisterSerializedScalarFunction(loader, ScalarFunction("tempSubtype", {TemporalTypes::tint()}, LogicalType::VARCHAR, Gen_temporal_subtype));
     RegisterSerializedScalarFunction(loader, ScalarFunction("tempSubtype", {TemporalTypes::tbigint()}, LogicalType::VARCHAR, Gen_temporal_subtype));
     RegisterSerializedScalarFunction(loader, ScalarFunction("tempSubtype", {TemporalTypes::tbool()}, LogicalType::VARCHAR, Gen_temporal_subtype));
@@ -17940,6 +18117,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) {
     RegisterSerializedScalarFunction(loader, ScalarFunction("tempSubtype", {H3indexTypes::th3index()}, LogicalType::VARCHAR, Gen_temporal_subtype));
     RegisterSerializedScalarFunction(loader, ScalarFunction("tempSubtype", {QuadbinTypes::tquadbin()}, LogicalType::VARCHAR, Gen_temporal_subtype));
     RegisterSerializedScalarFunction(loader, ScalarFunction("tempSubtype", {TJsonbTypes::tjsonb()}, LogicalType::VARCHAR, Gen_temporal_subtype));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("tempSubtype", {TPcpointTypes::tpcpoint()}, LogicalType::VARCHAR, Gen_temporal_subtype));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("tempSubtype", {TPcpatchTypes::tpcpatch()}, LogicalType::VARCHAR, Gen_temporal_subtype));
     RegisterSerializedScalarFunction(loader, ScalarFunction("tempBasetype", {TemporalTypes::tint()}, LogicalType::VARCHAR, Gen_temporal_basetype_name));
     RegisterSerializedScalarFunction(loader, ScalarFunction("tempBasetype", {TemporalTypes::tbigint()}, LogicalType::VARCHAR, Gen_temporal_basetype_name));
     RegisterSerializedScalarFunction(loader, ScalarFunction("tempBasetype", {TemporalTypes::tbool()}, LogicalType::VARCHAR, Gen_temporal_basetype_name));
@@ -17953,6 +18132,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) {
     RegisterSerializedScalarFunction(loader, ScalarFunction("tempBasetype", {H3indexTypes::th3index()}, LogicalType::VARCHAR, Gen_temporal_basetype_name));
     RegisterSerializedScalarFunction(loader, ScalarFunction("tempBasetype", {QuadbinTypes::tquadbin()}, LogicalType::VARCHAR, Gen_temporal_basetype_name));
     RegisterSerializedScalarFunction(loader, ScalarFunction("tempBasetype", {TJsonbTypes::tjsonb()}, LogicalType::VARCHAR, Gen_temporal_basetype_name));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("tempBasetype", {TPcpointTypes::tpcpoint()}, LogicalType::VARCHAR, Gen_temporal_basetype_name));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("tempBasetype", {TPcpatchTypes::tpcpatch()}, LogicalType::VARCHAR, Gen_temporal_basetype_name));
     RegisterSerializedScalarFunction(loader, ScalarFunction("upperInc", {TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_temporal_upper_inc));
     RegisterSerializedScalarFunction(loader, ScalarFunction("upperInc", {TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_temporal_upper_inc));
     RegisterSerializedScalarFunction(loader, ScalarFunction("upperInc", {TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_temporal_upper_inc));
@@ -17966,6 +18147,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) {
     RegisterSerializedScalarFunction(loader, ScalarFunction("upperInc", {H3indexTypes::th3index()}, LogicalType::BOOLEAN, Gen_temporal_upper_inc));
     RegisterSerializedScalarFunction(loader, ScalarFunction("upperInc", {QuadbinTypes::tquadbin()}, LogicalType::BOOLEAN, Gen_temporal_upper_inc));
     RegisterSerializedScalarFunction(loader, ScalarFunction("upperInc", {TJsonbTypes::tjsonb()}, LogicalType::BOOLEAN, Gen_temporal_upper_inc));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("upperInc", {TPcpointTypes::tpcpoint()}, LogicalType::BOOLEAN, Gen_temporal_upper_inc));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("upperInc", {TPcpatchTypes::tpcpatch()}, LogicalType::BOOLEAN, Gen_temporal_upper_inc));
     RegisterSerializedScalarFunction(loader, ScalarFunction("endValue", {TemporalTypes::tfloat()}, LogicalType::DOUBLE, Gen_tfloat_end_value));
     RegisterSerializedScalarFunction(loader, ScalarFunction("minValue", {TemporalTypes::tfloat()}, LogicalType::DOUBLE, Gen_tfloat_min_value));
     RegisterSerializedScalarFunction(loader, ScalarFunction("maxValue", {TemporalTypes::tfloat()}, LogicalType::DOUBLE, Gen_tfloat_max_value));
@@ -17997,6 +18180,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) {
     RegisterSerializedScalarFunction(loader, ScalarFunction("timestamps", {TgeogpointType::tgeogpoint()}, LogicalType::LIST(LogicalType::TIMESTAMP_TZ), Gen_temporal_timestamps));
     RegisterSerializedScalarFunction(loader, ScalarFunction("timestamps", {H3indexTypes::th3index()}, LogicalType::LIST(LogicalType::TIMESTAMP_TZ), Gen_temporal_timestamps));
     RegisterSerializedScalarFunction(loader, ScalarFunction("timestamps", {TJsonbTypes::tjsonb()}, LogicalType::LIST(LogicalType::TIMESTAMP_TZ), Gen_temporal_timestamps));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("timestamps", {TPcpointTypes::tpcpoint()}, LogicalType::LIST(LogicalType::TIMESTAMP_TZ), Gen_temporal_timestamps));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("timestamps", {TPcpatchTypes::tpcpatch()}, LogicalType::LIST(LogicalType::TIMESTAMP_TZ), Gen_temporal_timestamps));
     RegisterSerializedScalarFunction(loader, ScalarFunction("timestamps", {QuadbinTypes::tquadbin()}, LogicalType::LIST(LogicalType::TIMESTAMP_TZ), Gen_temporal_timestamps));
     RegisterSerializedScalarFunction(loader, ScalarFunction("timestamps", {TemporalTypes::tbool()}, LogicalType::LIST(LogicalType::TIMESTAMP_TZ), Gen_temporal_timestamps));
     RegisterSerializedScalarFunction(loader, ScalarFunction("timestamps", {TemporalTypes::tint()}, LogicalType::LIST(LogicalType::TIMESTAMP_TZ), Gen_temporal_timestamps));
@@ -19087,6 +19272,8 @@ static void RegisterGenerated_meos_temporal_comp_trad(ExtensionLoader &loader) {
     RegisterSerializedScalarFunction(loader, ScalarFunction("cmp", {H3indexTypes::th3index(), H3indexTypes::th3index()}, LogicalType::INTEGER, Gen_temporal_cmp));
     RegisterSerializedScalarFunction(loader, ScalarFunction("cmp", {QuadbinTypes::tquadbin(), QuadbinTypes::tquadbin()}, LogicalType::INTEGER, Gen_temporal_cmp));
     RegisterSerializedScalarFunction(loader, ScalarFunction("cmp", {TJsonbTypes::tjsonb(), TJsonbTypes::tjsonb()}, LogicalType::INTEGER, Gen_temporal_cmp));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("cmp", {TPcpointTypes::tpcpoint(), TPcpointTypes::tpcpoint()}, LogicalType::INTEGER, Gen_temporal_cmp));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("cmp", {TPcpatchTypes::tpcpatch(), TPcpatchTypes::tpcpatch()}, LogicalType::INTEGER, Gen_temporal_cmp));
     RegisterSerializedScalarFunction(loader, ScalarFunction("eq", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_temporal_eq));
     RegisterSerializedScalarFunction(loader, ScalarFunction("=", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_temporal_eq));
     RegisterSerializedScalarFunction(loader, ScalarFunction("eq", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_temporal_eq));
@@ -19113,6 +19300,10 @@ static void RegisterGenerated_meos_temporal_comp_trad(ExtensionLoader &loader) {
     RegisterSerializedScalarFunction(loader, ScalarFunction("=", {QuadbinTypes::tquadbin(), QuadbinTypes::tquadbin()}, LogicalType::BOOLEAN, Gen_temporal_eq));
     RegisterSerializedScalarFunction(loader, ScalarFunction("eq", {TJsonbTypes::tjsonb(), TJsonbTypes::tjsonb()}, LogicalType::BOOLEAN, Gen_temporal_eq));
     RegisterSerializedScalarFunction(loader, ScalarFunction("=", {TJsonbTypes::tjsonb(), TJsonbTypes::tjsonb()}, LogicalType::BOOLEAN, Gen_temporal_eq));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("eq", {TPcpointTypes::tpcpoint(), TPcpointTypes::tpcpoint()}, LogicalType::BOOLEAN, Gen_temporal_eq));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("=", {TPcpointTypes::tpcpoint(), TPcpointTypes::tpcpoint()}, LogicalType::BOOLEAN, Gen_temporal_eq));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("eq", {TPcpatchTypes::tpcpatch(), TPcpatchTypes::tpcpatch()}, LogicalType::BOOLEAN, Gen_temporal_eq));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("=", {TPcpatchTypes::tpcpatch(), TPcpatchTypes::tpcpatch()}, LogicalType::BOOLEAN, Gen_temporal_eq));
     RegisterSerializedScalarFunction(loader, ScalarFunction("ge", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_temporal_ge));
     RegisterSerializedScalarFunction(loader, ScalarFunction(">=", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_temporal_ge));
     RegisterSerializedScalarFunction(loader, ScalarFunction("ge", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_temporal_ge));
@@ -19139,6 +19330,10 @@ static void RegisterGenerated_meos_temporal_comp_trad(ExtensionLoader &loader) {
     RegisterSerializedScalarFunction(loader, ScalarFunction(">=", {QuadbinTypes::tquadbin(), QuadbinTypes::tquadbin()}, LogicalType::BOOLEAN, Gen_temporal_ge));
     RegisterSerializedScalarFunction(loader, ScalarFunction("ge", {TJsonbTypes::tjsonb(), TJsonbTypes::tjsonb()}, LogicalType::BOOLEAN, Gen_temporal_ge));
     RegisterSerializedScalarFunction(loader, ScalarFunction(">=", {TJsonbTypes::tjsonb(), TJsonbTypes::tjsonb()}, LogicalType::BOOLEAN, Gen_temporal_ge));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("ge", {TPcpointTypes::tpcpoint(), TPcpointTypes::tpcpoint()}, LogicalType::BOOLEAN, Gen_temporal_ge));
+    RegisterSerializedScalarFunction(loader, ScalarFunction(">=", {TPcpointTypes::tpcpoint(), TPcpointTypes::tpcpoint()}, LogicalType::BOOLEAN, Gen_temporal_ge));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("ge", {TPcpatchTypes::tpcpatch(), TPcpatchTypes::tpcpatch()}, LogicalType::BOOLEAN, Gen_temporal_ge));
+    RegisterSerializedScalarFunction(loader, ScalarFunction(">=", {TPcpatchTypes::tpcpatch(), TPcpatchTypes::tpcpatch()}, LogicalType::BOOLEAN, Gen_temporal_ge));
     RegisterSerializedScalarFunction(loader, ScalarFunction("gt", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_temporal_gt));
     RegisterSerializedScalarFunction(loader, ScalarFunction(">", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_temporal_gt));
     RegisterSerializedScalarFunction(loader, ScalarFunction("gt", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_temporal_gt));
@@ -19165,6 +19360,10 @@ static void RegisterGenerated_meos_temporal_comp_trad(ExtensionLoader &loader) {
     RegisterSerializedScalarFunction(loader, ScalarFunction(">", {QuadbinTypes::tquadbin(), QuadbinTypes::tquadbin()}, LogicalType::BOOLEAN, Gen_temporal_gt));
     RegisterSerializedScalarFunction(loader, ScalarFunction("gt", {TJsonbTypes::tjsonb(), TJsonbTypes::tjsonb()}, LogicalType::BOOLEAN, Gen_temporal_gt));
     RegisterSerializedScalarFunction(loader, ScalarFunction(">", {TJsonbTypes::tjsonb(), TJsonbTypes::tjsonb()}, LogicalType::BOOLEAN, Gen_temporal_gt));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("gt", {TPcpointTypes::tpcpoint(), TPcpointTypes::tpcpoint()}, LogicalType::BOOLEAN, Gen_temporal_gt));
+    RegisterSerializedScalarFunction(loader, ScalarFunction(">", {TPcpointTypes::tpcpoint(), TPcpointTypes::tpcpoint()}, LogicalType::BOOLEAN, Gen_temporal_gt));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("gt", {TPcpatchTypes::tpcpatch(), TPcpatchTypes::tpcpatch()}, LogicalType::BOOLEAN, Gen_temporal_gt));
+    RegisterSerializedScalarFunction(loader, ScalarFunction(">", {TPcpatchTypes::tpcpatch(), TPcpatchTypes::tpcpatch()}, LogicalType::BOOLEAN, Gen_temporal_gt));
     RegisterSerializedScalarFunction(loader, ScalarFunction("le", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_temporal_le));
     RegisterSerializedScalarFunction(loader, ScalarFunction("<=", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_temporal_le));
     RegisterSerializedScalarFunction(loader, ScalarFunction("le", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_temporal_le));
@@ -19191,6 +19390,10 @@ static void RegisterGenerated_meos_temporal_comp_trad(ExtensionLoader &loader) {
     RegisterSerializedScalarFunction(loader, ScalarFunction("<=", {QuadbinTypes::tquadbin(), QuadbinTypes::tquadbin()}, LogicalType::BOOLEAN, Gen_temporal_le));
     RegisterSerializedScalarFunction(loader, ScalarFunction("le", {TJsonbTypes::tjsonb(), TJsonbTypes::tjsonb()}, LogicalType::BOOLEAN, Gen_temporal_le));
     RegisterSerializedScalarFunction(loader, ScalarFunction("<=", {TJsonbTypes::tjsonb(), TJsonbTypes::tjsonb()}, LogicalType::BOOLEAN, Gen_temporal_le));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("le", {TPcpointTypes::tpcpoint(), TPcpointTypes::tpcpoint()}, LogicalType::BOOLEAN, Gen_temporal_le));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("<=", {TPcpointTypes::tpcpoint(), TPcpointTypes::tpcpoint()}, LogicalType::BOOLEAN, Gen_temporal_le));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("le", {TPcpatchTypes::tpcpatch(), TPcpatchTypes::tpcpatch()}, LogicalType::BOOLEAN, Gen_temporal_le));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("<=", {TPcpatchTypes::tpcpatch(), TPcpatchTypes::tpcpatch()}, LogicalType::BOOLEAN, Gen_temporal_le));
     RegisterSerializedScalarFunction(loader, ScalarFunction("lt", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_temporal_lt));
     RegisterSerializedScalarFunction(loader, ScalarFunction("<", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_temporal_lt));
     RegisterSerializedScalarFunction(loader, ScalarFunction("lt", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_temporal_lt));
@@ -19217,6 +19420,10 @@ static void RegisterGenerated_meos_temporal_comp_trad(ExtensionLoader &loader) {
     RegisterSerializedScalarFunction(loader, ScalarFunction("<", {QuadbinTypes::tquadbin(), QuadbinTypes::tquadbin()}, LogicalType::BOOLEAN, Gen_temporal_lt));
     RegisterSerializedScalarFunction(loader, ScalarFunction("lt", {TJsonbTypes::tjsonb(), TJsonbTypes::tjsonb()}, LogicalType::BOOLEAN, Gen_temporal_lt));
     RegisterSerializedScalarFunction(loader, ScalarFunction("<", {TJsonbTypes::tjsonb(), TJsonbTypes::tjsonb()}, LogicalType::BOOLEAN, Gen_temporal_lt));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("lt", {TPcpointTypes::tpcpoint(), TPcpointTypes::tpcpoint()}, LogicalType::BOOLEAN, Gen_temporal_lt));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("<", {TPcpointTypes::tpcpoint(), TPcpointTypes::tpcpoint()}, LogicalType::BOOLEAN, Gen_temporal_lt));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("lt", {TPcpatchTypes::tpcpatch(), TPcpatchTypes::tpcpatch()}, LogicalType::BOOLEAN, Gen_temporal_lt));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("<", {TPcpatchTypes::tpcpatch(), TPcpatchTypes::tpcpatch()}, LogicalType::BOOLEAN, Gen_temporal_lt));
     RegisterSerializedScalarFunction(loader, ScalarFunction("ne", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_temporal_ne));
     RegisterSerializedScalarFunction(loader, ScalarFunction("<>", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_temporal_ne));
     RegisterSerializedScalarFunction(loader, ScalarFunction("ne", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_temporal_ne));
@@ -19243,6 +19450,10 @@ static void RegisterGenerated_meos_temporal_comp_trad(ExtensionLoader &loader) {
     RegisterSerializedScalarFunction(loader, ScalarFunction("<>", {QuadbinTypes::tquadbin(), QuadbinTypes::tquadbin()}, LogicalType::BOOLEAN, Gen_temporal_ne));
     RegisterSerializedScalarFunction(loader, ScalarFunction("ne", {TJsonbTypes::tjsonb(), TJsonbTypes::tjsonb()}, LogicalType::BOOLEAN, Gen_temporal_ne));
     RegisterSerializedScalarFunction(loader, ScalarFunction("<>", {TJsonbTypes::tjsonb(), TJsonbTypes::tjsonb()}, LogicalType::BOOLEAN, Gen_temporal_ne));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("ne", {TPcpointTypes::tpcpoint(), TPcpointTypes::tpcpoint()}, LogicalType::BOOLEAN, Gen_temporal_ne));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("<>", {TPcpointTypes::tpcpoint(), TPcpointTypes::tpcpoint()}, LogicalType::BOOLEAN, Gen_temporal_ne));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("ne", {TPcpatchTypes::tpcpatch(), TPcpatchTypes::tpcpatch()}, LogicalType::BOOLEAN, Gen_temporal_ne));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("<>", {TPcpatchTypes::tpcpatch(), TPcpatchTypes::tpcpatch()}, LogicalType::BOOLEAN, Gen_temporal_ne));
 }
 
 static void RegisterGenerated_meos_temporal_constructor(ExtensionLoader &loader) {
@@ -19316,6 +19527,10 @@ static void RegisterGenerated_meos_temporal_conversion(ExtensionLoader &loader)
     RegisterSerializedScalarFunction(loader, ScalarFunction("::", {H3indexTypes::th3index()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan));
     RegisterSerializedScalarFunction(loader, ScalarFunction("timeSpan", {TJsonbTypes::tjsonb()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan));
     RegisterSerializedScalarFunction(loader, ScalarFunction("::", {TJsonbTypes::tjsonb()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("timeSpan", {TPcpointTypes::tpcpoint()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("::", {TPcpointTypes::tpcpoint()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("timeSpan", {TPcpatchTypes::tpcpatch()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("::", {TPcpatchTypes::tpcpatch()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan));
     RegisterSerializedScalarFunction(loader, ScalarFunction("timeSpan", {QuadbinTypes::tquadbin()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan));
     RegisterSerializedScalarFunction(loader, ScalarFunction("::", {QuadbinTypes::tquadbin()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan));
     RegisterSerializedScalarFunction(loader, ScalarFunction("timeSpan", {TemporalTypes::tbool()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan));
@@ -19370,6 +19585,10 @@ static void RegisterGenerated_meos_temporal_inout(ExtensionLoader &loader) {
     RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {H3indexTypes::th3index(), LogicalType::VARCHAR}, LogicalType::VARCHAR, Gen_temporal_as_hexwkb));
     RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {TJsonbTypes::tjsonb()}, LogicalType::VARCHAR, Gen_temporal_as_hexwkb));
     RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {TJsonbTypes::tjsonb(), LogicalType::VARCHAR}, LogicalType::VARCHAR, Gen_temporal_as_hexwkb));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {TPcpointTypes::tpcpoint()}, LogicalType::VARCHAR, Gen_temporal_as_hexwkb));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {TPcpointTypes::tpcpoint(), LogicalType::VARCHAR}, LogicalType::VARCHAR, Gen_temporal_as_hexwkb));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {TPcpatchTypes::tpcpatch()}, LogicalType::VARCHAR, Gen_temporal_as_hexwkb));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {TPcpatchTypes::tpcpatch(), LogicalType::VARCHAR}, LogicalType::VARCHAR, Gen_temporal_as_hexwkb));
     RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {TemporalTypes::tbool()}, LogicalType::VARCHAR, Gen_temporal_as_hexwkb));
     RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {TemporalTypes::tbool(), LogicalType::VARCHAR}, LogicalType::VARCHAR, Gen_temporal_as_hexwkb));
     RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {TemporalTypes::tint()}, LogicalType::VARCHAR, Gen_temporal_as_hexwkb));
@@ -19554,6 +19773,8 @@ static void RegisterGenerated_meos_temporal_restrict(ExtensionLoader &loader) {
     RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {H3indexTypes::th3index(), LogicalType::TIMESTAMP_TZ}, H3indexTypes::th3index(), Gen_temporal_at_timestamptz));
     RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {QuadbinTypes::tquadbin(), LogicalType::TIMESTAMP_TZ}, QuadbinTypes::tquadbin(), Gen_temporal_at_timestamptz));
     RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TJsonbTypes::tjsonb(), LogicalType::TIMESTAMP_TZ}, TJsonbTypes::tjsonb(), Gen_temporal_at_timestamptz));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TPcpointTypes::tpcpoint(), LogicalType::TIMESTAMP_TZ}, TPcpointTypes::tpcpoint(), Gen_temporal_at_timestamptz));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TPcpatchTypes::tpcpatch(), LogicalType::TIMESTAMP_TZ}, TPcpatchTypes::tpcpatch(), Gen_temporal_at_timestamptz));
     RegisterSerializedScalarFunction(loader, ScalarFunction("beforeTimestamp", {TemporalTypes::tint(), LogicalType::TIMESTAMP_TZ, LogicalType::BOOLEAN}, TemporalTypes::tint(), Gen_temporal_before_timestamptz));
     RegisterSerializedScalarFunction(loader, ScalarFunction("beforeTimestamp", {TemporalTypes::tbigint(), LogicalType::TIMESTAMP_TZ, LogicalType::BOOLEAN}, TemporalTypes::tbigint(), Gen_temporal_before_timestamptz));
     RegisterSerializedScalarFunction(loader, ScalarFunction("beforeTimestamp", {TemporalTypes::tbool(), LogicalType::TIMESTAMP_TZ, LogicalType::BOOLEAN}, TemporalTypes::tbool(), Gen_temporal_before_timestamptz));
@@ -19590,6 +19811,8 @@ static void RegisterGenerated_meos_temporal_restrict(ExtensionLoader &loader) {
     RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {H3indexTypes::th3index(), LogicalType::TIMESTAMP_TZ}, H3indexTypes::th3index(), Gen_temporal_minus_timestamptz));
     RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {QuadbinTypes::tquadbin(), LogicalType::TIMESTAMP_TZ}, QuadbinTypes::tquadbin(), Gen_temporal_minus_timestamptz));
     RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TJsonbTypes::tjsonb(), LogicalType::TIMESTAMP_TZ}, TJsonbTypes::tjsonb(), Gen_temporal_minus_timestamptz));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TPcpointTypes::tpcpoint(), LogicalType::TIMESTAMP_TZ}, TPcpointTypes::tpcpoint(), Gen_temporal_minus_timestamptz));
+    RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TPcpatchTypes::tpcpatch(), LogicalType::TIMESTAMP_TZ}, TPcpatchTypes::tpcpatch(), Gen_temporal_minus_timestamptz));
     RegisterSerializedScalarFunction(loader, ScalarFunction("atValue", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, TemporalTypes::tfloat(), Gen_tfloat_at_value));
     RegisterSerializedScalarFunction(loader, ScalarFunction("minusValue", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, TemporalTypes::tfloat(), Gen_tfloat_minus_value));
     RegisterSerializedScalarFunction(loader, ScalarFunction("atValue", {TemporalTypes::tint(), LogicalType::INTEGER}, TemporalTypes::tint(), Gen_tint_at_value));
@@ -19812,6 +20035,8 @@ void RegisterGeneratedTemporalUdfs(ExtensionLoader &loader) {
     RegisterGenerated_meos_json_conversion(loader);
     RegisterGenerated_meos_json_json(loader);
     RegisterGenerated_meos_json_restrict(loader);
+    RegisterGenerated_meos_pointcloud_accessor(loader);
+    RegisterGenerated_meos_pointcloud_restrict(loader);
     RegisterGenerated_meos_quadbin_accessor(loader);
     RegisterGenerated_meos_quadbin_conversion(loader);
     RegisterGenerated_meos_setspan_accessor(loader);
diff --git a/src/include/meos_wrapper_simple.hpp b/src/include/meos_wrapper_simple.hpp
index a116b16f..3c66cef1 100644
--- a/src/include/meos_wrapper_simple.hpp
+++ b/src/include/meos_wrapper_simple.hpp
@@ -12,12 +12,15 @@ extern "C" {
     // family type declarations and cross-family conversions (e.g.
     // tcbuffer_to_tfloat, ttext_to_tjsonb, tbigint_to_tquadbin) live here, not in
     // the meos.h umbrella. The port builds every family the generated UDFs call
-    // into (pointcloud is off: it surfaces no type or UDF yet). (Alphabetical also
-    // keeps meos_pose.h before meos_rgeo.h, which depends on it.)
+    // into. meos_pointcloud.h must be wrapped here (C linkage) now that the
+    // pointcloud value surface (tpcpoint/tpcpatch startValue/atValue/…) generates
+    // and links against libmeos. (Alphabetical also keeps meos_pose.h before
+    // meos_rgeo.h, which depends on it.)
     #include <meos_cbuffer.h>
     #include <meos_h3.h>
     #include <meos_json.h>
     #include <meos_npoint.h>
+    #include <meos_pointcloud.h>
     #include <meos_pose.h>
     #include <meos_quadbin.h>
     #include <meos_rgeo.h>
diff --git a/src/include/pointcloud/tpcpatch.hpp b/src/include/pointcloud/tpcpatch.hpp
index 0f14a0ff..6dccfa06 100644
--- a/src/include/pointcloud/tpcpatch.hpp
+++ b/src/include/pointcloud/tpcpatch.hpp
@@ -11,7 +11,8 @@ namespace duckdb {
 
 
 struct TPcpatchTypes {
-    static LogicalType TPCPATCH();
+    static LogicalType pcpatch();
+    static LogicalType tpcpatch();
     static LogicalType GEOMETRY();
     static void RegisterTypes(ExtensionLoader &loader);
     static void RegisterScalarFunctions(ExtensionLoader &loader);
@@ -22,6 +23,9 @@ struct TPcpatchTypes {
 struct TpcpatchFunctions {
     static bool StringToTpcpatch(Vector &source, Vector &result, idx_t count, CastParameters &parameters);
     static bool TpcpatchToString(Vector &source, Vector &result, idx_t count, CastParameters &parameters);
+    // Base pcpatch value (BLOB-alias) -> VARCHAR render cast (pcpatch_hex_out), so the
+    // generated startValue/endValue base value renders as hex-WKB text (cbuffer sibling).
+    static bool Pcpatch_out_cast(Vector &source, Vector &result, idx_t count, CastParameters &parameters);
     static bool WkbBlobToGeometry(Vector &source, Vector &result, idx_t count, CastParameters &parameters);
 };
 
diff --git a/src/include/pointcloud/tpcpoint.hpp b/src/include/pointcloud/tpcpoint.hpp
index 54acd200..33d8a0d4 100644
--- a/src/include/pointcloud/tpcpoint.hpp
+++ b/src/include/pointcloud/tpcpoint.hpp
@@ -11,7 +11,8 @@ namespace duckdb {
 
 
 struct TPcpointTypes {
-    static LogicalType TPCPOINT();
+    static LogicalType pcpoint();
+    static LogicalType tpcpoint();
     static LogicalType GEOMETRY();
     static void RegisterTypes(ExtensionLoader &loader);
     static void RegisterScalarFunctions(ExtensionLoader &loader);
@@ -22,6 +23,9 @@ struct TPcpointTypes {
 struct TpcpointFunctions {
     static bool StringToTpcpoint(Vector &source, Vector &result, idx_t count, CastParameters &parameters);
     static bool TpcpointToString(Vector &source, Vector &result, idx_t count, CastParameters &parameters);
+    // Base pcpoint value (BLOB-alias) -> VARCHAR render cast (pcpoint_hex_out), so the
+    // generated startValue/endValue base value renders as hex-WKB text (cbuffer sibling).
+    static bool Pcpoint_out_cast(Vector &source, Vector &result, idx_t count, CastParameters &parameters);
     static bool WkbBlobToGeometry(Vector &source, Vector &result, idx_t count, CastParameters &parameters);
 };
 
diff --git a/src/pointcloud/tpcpatch.cpp b/src/pointcloud/tpcpatch.cpp
index e9c3d5bf..114d1683 100644
--- a/src/pointcloud/tpcpatch.cpp
+++ b/src/pointcloud/tpcpatch.cpp
@@ -48,9 +48,15 @@ extern "C" {
 
 namespace duckdb {
 
-LogicalType TPcpatchTypes::TPCPATCH() {
+LogicalType TPcpatchTypes::pcpatch() {
     auto type = LogicalType(LogicalTypeId::BLOB);
-    type.SetAlias("TPCPATCH");
+    type.SetAlias("pcpatch");
+    return type;
+}
+
+LogicalType TPcpatchTypes::tpcpatch() {
+    auto type = LogicalType(LogicalTypeId::BLOB);
+    type.SetAlias("tpcpatch");
     return type;
 }
 
@@ -72,7 +78,7 @@ static void Tpcpatch_constructor(DataChunk &args, ExpressionState &state, Vector
             // T_TPCPATCH).
             Temporal *tinst = temporal_in(input.c_str(), T_TPCPATCH);
             if (!tinst) {
-                throw InvalidInputException("Invalid TPCPATCH input: " + input);
+                throw InvalidInputException("Invalid tpcpatch input: " + input);
             }
 
             size_t data_size = temporal_mem_size(tinst);
@@ -80,7 +86,7 @@ static void Tpcpatch_constructor(DataChunk &args, ExpressionState &state, Vector
             uint8_t *data_buffer = (uint8_t*)malloc(data_size);
             if (!data_buffer) {
                 free(tinst);
-                throw InvalidInputException("Failed to allocate memory for TPCPATCH data");
+                throw InvalidInputException("Failed to allocate memory for tpcpatch data");
             }
 
             memcpy(data_buffer, tinst, data_size);
@@ -447,13 +453,13 @@ static void Temporal_to_tstzspan(DataChunk &args, ExpressionState &state, Vector
             Temporal *temp = reinterpret_cast<Temporal*>(const_cast<char*>(input.c_str()));
 
             if (!temp) {
-                throw InvalidInputException("Invalid TPCPATCH data: null pointer");
+                throw InvalidInputException("Invalid tpcpatch data: null pointer");
             }
 
             Span *timespan = temporal_to_tstzspan(temp);
 
             if (!timespan) {
-                throw InvalidInputException("Failed to extract timespan from TPCPATCH");
+                throw InvalidInputException("Failed to extract timespan from tpcpatch");
             }
 
             size_t span_size = sizeof(Span);
@@ -497,12 +503,12 @@ static void Temporal_to_tinstant(DataChunk &args, ExpressionState &state, Vector
             Temporal *temp = reinterpret_cast<Temporal*>(const_cast<char*>(input.c_str()));
 
             if (!temp) {
-                throw InvalidInputException("Invalid TPCPATCH data: null pointer");
+                throw InvalidInputException("Invalid tpcpatch data: null pointer");
             }
 
             TInstant *inst = temporal_as_tinstant(temp);
             if (!inst) {
-                throw InvalidInputException("Failed to convert TPCPATCH to TInstant");
+                throw InvalidInputException("Failed to convert tpcpatch to TInstant");
             }
 
             size_t inst_size = temporal_mem_size((Temporal*)inst);
@@ -547,7 +553,7 @@ static void Temporal_set_interp(DataChunk &args, ExpressionState &state, Vector
 
             Temporal *temp = reinterpret_cast<Temporal*>(const_cast<char*>(input.c_str()));
             if (!temp) {
-                throw InvalidInputException("Invalid TPCPATCH data: null pointer");
+                throw InvalidInputException("Invalid tpcpatch data: null pointer");
             }
 
             std::string interp_str = interp_str_t.GetString();
@@ -597,14 +603,14 @@ static void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &resu
 
             Temporal *temp1 = reinterpret_cast<Temporal*>(const_cast<char*>(tgeom1.c_str()));
             if (!temp1) {
-                throw InvalidInputException("Invalid TPCPATCH data: null pointer");
+                throw InvalidInputException("Invalid tpcpatch data: null pointer");
             }
 
             std::string tgeom2 = tgeom2_str_t.GetString();
 
             Temporal *temp2 = reinterpret_cast<Temporal*>(const_cast<char*>(tgeom2.c_str()));
             if (!temp2) {
-                throw InvalidInputException("Invalid TPCPATCH data: null pointer");
+                throw InvalidInputException("Invalid tpcpatch data: null pointer");
             }
 
             Temporal *result_temp = temporal_merge(temp1, temp2);
@@ -653,7 +659,7 @@ static void Temporal_subtype(DataChunk &args, ExpressionState &state, Vector &re
 
             Temporal *temp = reinterpret_cast<Temporal*>(const_cast<char*>(input.c_str()));
             if (!temp) {
-                throw InvalidInputException("Invalid TPCPATCH data: null pointer");
+                throw InvalidInputException("Invalid tpcpatch data: null pointer");
             }
 
             const char *subtype_str = temporal_subtype(temp);
@@ -689,7 +695,7 @@ static void Temporal_interp(DataChunk &args, ExpressionState &state, Vector &res
 
             Temporal *temp = reinterpret_cast<Temporal*>(const_cast<char*>(input.c_str()));
             if (!temp) {
-                throw InvalidInputException("Invalid TPCPATCH data: null pointer");
+                throw InvalidInputException("Invalid tpcpatch data: null pointer");
             }
 
 
@@ -722,7 +728,7 @@ static void Temporal_mem_size(DataChunk &args, ExpressionState &state, Vector &r
 
             Temporal *temp = reinterpret_cast<Temporal*>(const_cast<char*>(input.c_str()));
             if (!temp) {
-                throw InvalidInputException("Invalid TPCPATCH data: null pointer");
+                throw InvalidInputException("Invalid tpcpatch data: null pointer");
             }
 
             size_t mem_size = temporal_mem_size(temp);
@@ -789,75 +795,32 @@ static void Tinstant_value(DataChunk &args, ExpressionState &state, Vector &resu
 
 
 
-static void Temporal_start_value(DataChunk &args, ExpressionState &state, Vector &result) {
-    auto count = args.size();
-    auto &input_vec = args.data[0];
+/* Temporal_start_value/Temporal_end_value retired: startValue/endValue are now
+ * generated (return the pcpatch base value, rendered via the pcpatch->VARCHAR cast). */
 
+/* Base pcpatch value (BLOB-alias) -> VARCHAR render cast, mirroring the cbuffer
+ * sibling's Cbuffer_out_cast. The generated startValue/endValue return the pcpatch
+ * base value; DuckDB renders it through this cast via the schema-free pcpatch_hex_out
+ * (hex-WKB text), the same form the retired hand accessors produced. */
+bool TpcpatchFunctions::Pcpatch_out_cast(
+    Vector &source, Vector &result, idx_t count, CastParameters &parameters)
+{
     UnaryExecutor::Execute<string_t, string_t>(
-        input_vec, result, count,
-        [&](string_t input_str) -> string_t {
-            std::string input = input_str.GetString();
-
-            Temporal *temp = reinterpret_cast<Temporal*>(const_cast<char*>(input.c_str()));
-
-            // temporal_start_value returns a freshly allocated copy of
-            // the pcpatch value (datum_copy), which the caller owns.
-            Datum start_datum = temporal_start_value(temp);
-
-            Pcpatch *pt = reinterpret_cast<Pcpatch*>(start_datum);
+        source, result, count,
+        [&](string_t blob) -> string_t {
+            size_t sz = blob.GetSize();
+            uint8_t *copy = (uint8_t *)malloc(sz);
+            memcpy(copy, blob.GetData(), sz);
+            Pcpatch *pt = reinterpret_cast<Pcpatch *>(copy);
             char *str = pcpatch_hex_out(pt, 15);
-            if (!str) {
-                free(pt);
-                throw InvalidInputException("Failed to convert pcpatch value to text");
-            }
-            std::string output(str);
-            string_t stored_result = StringVector::AddString(result, output);
-
-            free(str);
             free(pt);
-
-            return stored_result;
-        });
-
-    if (count == 1) {
-        result.SetVectorType(VectorType::CONSTANT_VECTOR);
-    }
-}
-
-
-static void Temporal_end_value(DataChunk &args, ExpressionState &state, Vector &result) {
-    auto count = args.size();
-    auto &input_vec = args.data[0];
-
-    UnaryExecutor::Execute<string_t, string_t>(
-        input_vec, result, count,
-        [&](string_t input_str) -> string_t {
-            std::string input = input_str.GetString();
-
-            Temporal *temp = reinterpret_cast<Temporal*>(const_cast<char*>(input.c_str()));
-
-            // temporal_end_value returns a freshly allocated copy of
-            // the pcpatch value (datum_copy), which the caller owns.
-            Datum end_datum = temporal_end_value(temp);
-
-            Pcpatch *pt = reinterpret_cast<Pcpatch*>(end_datum);
-            char *str = pcpatch_hex_out(pt, 15);
-            if (!str) {
-                free(pt);
+            if (!str)
                 throw InvalidInputException("Failed to convert pcpatch value to text");
-            }
-            std::string output(str);
-            string_t stored_result = StringVector::AddString(result, output);
-
+            std::string s(str);
             free(str);
-            free(pt);
-
-            return stored_result;
+            return StringVector::AddString(result, s);
         });
-
-    if (count == 1) {
-        result.SetVectorType(VectorType::CONSTANT_VECTOR);
-    }
+    return true;
 }
 
 static void Tpcpatch_pcid(DataChunk &args, ExpressionState &state, Vector &result) {
@@ -1109,12 +1072,12 @@ static void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector
             size_t data_size = input_geom_str.GetSize();
 
             if (data_size < sizeof(void*)) {
-                throw InvalidInputException("Invalid TPCPATCH data: insufficient size");
+                throw InvalidInputException("Invalid tpcpatch data: insufficient size");
             }
 
             uint8_t *data_copy = (uint8_t*)malloc(data_size);
             if (!data_copy) {
-                throw InvalidInputException("Failed to allocate memory for TPCPATCH deserialization");
+                throw InvalidInputException("Failed to allocate memory for tpcpatch deserialization");
             }
             memcpy(data_copy, data, data_size);
 
@@ -1122,7 +1085,7 @@ static void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector
 
             if (!temp) {
                 free(data_copy);
-                throw InvalidInputException("Invalid TPCPATCH data: null pointer");
+                throw InvalidInputException("Invalid tpcpatch data: null pointer");
             }
 
             TimestampTz meos_t = temp->t;
@@ -1145,87 +1108,87 @@ static void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector
 void TPcpatchTypes::RegisterScalarFunctions(ExtensionLoader &loader) {
 
     auto tpcpatch_function = ScalarFunction(
-        "TPCPATCH",
+        "tpcpatch",
         {LogicalType::VARCHAR},
-        TPcpatchTypes::TPCPATCH(),
+        TPcpatchTypes::tpcpatch(),
         Tpcpatch_constructor
     );
     duckdb::RegisterSerializedScalarFunction(loader,  tpcpatch_function);
 
     auto tpcpatch_from_timestamp_function = ScalarFunction(
-        "TPCPATCH",
+        "tpcpatch",
         {LogicalType::VARCHAR, LogicalType::TIMESTAMP_TZ},
-        TPcpatchTypes::TPCPATCH(),
+        TPcpatchTypes::tpcpatch(),
         Tpcpatchinst_constructor);
     duckdb::RegisterSerializedScalarFunction(loader,  tpcpatch_from_timestamp_function);
 
      auto tpcpatch_from_tstzspan_function = ScalarFunction(
-        "TPCPATCH",
+        "tpcpatch",
         {LogicalType::VARCHAR, SpanTypes::tstzspan(), LogicalType::VARCHAR},
-        TPcpatchTypes::TPCPATCH(),
+        TPcpatchTypes::tpcpatch(),
         Tpcpatch_sequence_from_tstzspan
     );
     duckdb::RegisterSerializedScalarFunction(loader,  tpcpatch_from_tstzspan_function);
 
     auto tpcpatch_from_tstzspan_default = ScalarFunction(
-        "TPCPATCH",
+        "tpcpatch",
         {LogicalType::VARCHAR, SpanTypes::tstzspan()},
-        TPcpatchTypes::TPCPATCH(),
+        TPcpatchTypes::tpcpatch(),
         Tpcpatch_sequence_from_tstzspan
     );
     duckdb::RegisterSerializedScalarFunction(loader,  tpcpatch_from_tstzspan_default);
 
      auto tpcpatchseqarr_1param= ScalarFunction(
         "tpcpatchSeq",
-        {LogicalType::LIST(TPcpatchTypes::TPCPATCH())},
-        TPcpatchTypes::TPCPATCH(),
+        {LogicalType::LIST(TPcpatchTypes::tpcpatch())},
+        TPcpatchTypes::tpcpatch(),
         Tpcpatch_sequence_constructor
     );
     duckdb::RegisterSerializedScalarFunction(loader,  tpcpatchseqarr_1param);
 
     auto tpcpatchseqarr_2params = ScalarFunction(
         "tpcpatchSeq",
-        {LogicalType::LIST(TPcpatchTypes::TPCPATCH()), LogicalType::VARCHAR},
-        TPcpatchTypes::TPCPATCH(),
+        {LogicalType::LIST(TPcpatchTypes::tpcpatch()), LogicalType::VARCHAR},
+        TPcpatchTypes::tpcpatch(),
         Tpcpatch_sequence_constructor
     );
     duckdb::RegisterSerializedScalarFunction(loader,  tpcpatchseqarr_2params);
 
     auto tpcpatchseqarr_3params = ScalarFunction(
         "tpcpatchSeq",
-        {LogicalType::LIST(TPcpatchTypes::TPCPATCH()), LogicalType::VARCHAR, LogicalType::BOOLEAN},
-        TPcpatchTypes::TPCPATCH(),
+        {LogicalType::LIST(TPcpatchTypes::tpcpatch()), LogicalType::VARCHAR, LogicalType::BOOLEAN},
+        TPcpatchTypes::tpcpatch(),
         Tpcpatch_sequence_constructor
     );
     duckdb::RegisterSerializedScalarFunction(loader,  tpcpatchseqarr_3params);
 
     auto tpcpatchseqarr_4params = ScalarFunction(
         "tpcpatchSeq",
-        {LogicalType::LIST(TPcpatchTypes::TPCPATCH()), LogicalType::VARCHAR, LogicalType::BOOLEAN, LogicalType::BOOLEAN},
-        TPcpatchTypes::TPCPATCH(),
+        {LogicalType::LIST(TPcpatchTypes::tpcpatch()), LogicalType::VARCHAR, LogicalType::BOOLEAN, LogicalType::BOOLEAN},
+        TPcpatchTypes::tpcpatch(),
         Tpcpatch_sequence_constructor
     );
     duckdb::RegisterSerializedScalarFunction(loader,  tpcpatchseqarr_4params);
 
     auto tpcpatch_to_timespan_function = ScalarFunction(
         "timeSpan",
-        {TPcpatchTypes::TPCPATCH()},
+        {TPcpatchTypes::tpcpatch()},
         SpanTypes::tstzspan(),
         Temporal_to_tstzspan);
     duckdb::RegisterSerializedScalarFunction(loader,  tpcpatch_to_timespan_function);
 
     auto tpcpatch_to_tinstant_function = ScalarFunction(
         "tpcpatchInst",
-        {TPcpatchTypes::TPCPATCH()},
-        TPcpatchTypes::TPCPATCH(),
+        {TPcpatchTypes::tpcpatch()},
+        TPcpatchTypes::tpcpatch(),
         Temporal_to_tinstant);
     duckdb::RegisterSerializedScalarFunction(loader,  tpcpatch_to_tinstant_function);
 
 
     auto setInterp_function = ScalarFunction(
         "setInterp",
-        {TPcpatchTypes::TPCPATCH(), LogicalType::VARCHAR},
-        TPcpatchTypes::TPCPATCH(),
+        {TPcpatchTypes::tpcpatch(), LogicalType::VARCHAR},
+        TPcpatchTypes::tpcpatch(),
         Temporal_set_interp
     );
     duckdb::RegisterSerializedScalarFunction(loader,  setInterp_function);
@@ -1233,15 +1196,15 @@ void TPcpatchTypes::RegisterScalarFunctions(ExtensionLoader &loader) {
 
     auto merge_function = ScalarFunction(
         "merge",
-        {TPcpatchTypes::TPCPATCH(), TPcpatchTypes::TPCPATCH()},
-        TPcpatchTypes::TPCPATCH(),
+        {TPcpatchTypes::tpcpatch(), TPcpatchTypes::tpcpatch()},
+        TPcpatchTypes::tpcpatch(),
         Temporal_merge
     );
     duckdb::RegisterSerializedScalarFunction(loader,  merge_function);
 
     auto tempSubtype_function = ScalarFunction(
         "tempSubtype",
-        {TPcpatchTypes::TPCPATCH()},
+        {TPcpatchTypes::tpcpatch()},
         LogicalType::VARCHAR,
         Temporal_subtype
     );
@@ -1249,7 +1212,7 @@ void TPcpatchTypes::RegisterScalarFunctions(ExtensionLoader &loader) {
 
     auto interp_function = ScalarFunction(
         "interp",
-        {TPcpatchTypes::TPCPATCH()},
+        {TPcpatchTypes::tpcpatch()},
         LogicalType::VARCHAR,
         Temporal_interp
     );
@@ -1257,7 +1220,7 @@ void TPcpatchTypes::RegisterScalarFunctions(ExtensionLoader &loader) {
 
     auto memSize_function = ScalarFunction(
         "memSize",
-        {TPcpatchTypes::TPCPATCH()},
+        {TPcpatchTypes::tpcpatch()},
         LogicalType::INTEGER,
         Temporal_mem_size
     );
@@ -1265,32 +1228,20 @@ void TPcpatchTypes::RegisterScalarFunctions(ExtensionLoader &loader) {
 
     auto getValue_function = ScalarFunction(
         "getValue",
-        {TPcpatchTypes::TPCPATCH()},
+        {TPcpatchTypes::tpcpatch()},
         LogicalType::VARCHAR,
         Tinstant_value
     );
     duckdb::RegisterSerializedScalarFunction(loader,  getValue_function);
 
 
-    auto tpcpatch_start_value_function = ScalarFunction(
-        "startValue",
-        {TPcpatchTypes::TPCPATCH()},
-        LogicalType::VARCHAR,
-        Temporal_start_value
-    );
-    duckdb::RegisterSerializedScalarFunction(loader,  tpcpatch_start_value_function);
-
-    auto tpcpatch_end_value_function = ScalarFunction(
-        "endValue",
-        {TPcpatchTypes::TPCPATCH()},
-        LogicalType::VARCHAR,
-        Temporal_end_value
-    );
-    duckdb::RegisterSerializedScalarFunction(loader,  tpcpatch_end_value_function);
+    /* startValue/endValue are now GENERATED (they return the pcpatch base value,
+     * rendered as hex-WKB text via the pcpatch->VARCHAR cast), mirroring the cbuffer
+     * sibling; the hand VARCHAR registrations are retired to avoid an ambiguous overload. */
 
     auto tpcpatch_pcid_function = ScalarFunction(
         "pcid",
-        {TPcpatchTypes::TPCPATCH()},
+        {TPcpatchTypes::tpcpatch()},
         LogicalType::INTEGER,
         Tpcpatch_pcid
     );
@@ -1298,7 +1249,7 @@ void TPcpatchTypes::RegisterScalarFunctions(ExtensionLoader &loader) {
 
     auto tpcpatch_numpoints_function = ScalarFunction(
         "numPoints",
-        {TPcpatchTypes::TPCPATCH()},
+        {TPcpatchTypes::tpcpatch()},
         LogicalType::INTEGER,
         Tpcpatch_numpoints
     );
@@ -1306,24 +1257,24 @@ void TPcpatchTypes::RegisterScalarFunctions(ExtensionLoader &loader) {
 
     auto startInstant_function = ScalarFunction(
         "startInstant",
-        {TPcpatchTypes::TPCPATCH()},
-        TPcpatchTypes::TPCPATCH(),
+        {TPcpatchTypes::tpcpatch()},
+        TPcpatchTypes::tpcpatch(),
         Temporal_start_instant
     );
     duckdb::RegisterSerializedScalarFunction(loader,  startInstant_function);
 
     auto endInstant_function = ScalarFunction(
         "endInstant",
-        {TPcpatchTypes::TPCPATCH()},
-        TPcpatchTypes::TPCPATCH(),
+        {TPcpatchTypes::tpcpatch()},
+        TPcpatchTypes::tpcpatch(),
         Temporal_end_instant
     );
     duckdb::RegisterSerializedScalarFunction(loader,  endInstant_function);
 
     auto instantN_function = ScalarFunction(
         "instantN",
-        {TPcpatchTypes::TPCPATCH(), LogicalType::INTEGER},
-        TPcpatchTypes::TPCPATCH(),
+        {TPcpatchTypes::tpcpatch(), LogicalType::INTEGER},
+        TPcpatchTypes::tpcpatch(),
         Temporal_instant_n
     );
     duckdb::RegisterSerializedScalarFunction(loader,  instantN_function);
@@ -1331,7 +1282,7 @@ void TPcpatchTypes::RegisterScalarFunctions(ExtensionLoader &loader) {
 
     auto tpcpatch_gettimestamptz_function = ScalarFunction(
         "getTimestamp",
-        {TPcpatchTypes::TPCPATCH()},
+        {TPcpatchTypes::tpcpatch()},
         LogicalType::TIMESTAMP_TZ,
         Tinstant_timestamptz);
     duckdb::RegisterSerializedScalarFunction(loader,  tpcpatch_gettimestamptz_function);
@@ -1344,7 +1295,7 @@ void TPcpatchTypes::RegisterScalarFunctions(ExtensionLoader &loader) {
     // generic handlers wired for tgeompoint in temporal_functions.cpp.
     // ===================================================================
 
-    const LogicalType TGEOM = TPcpatchTypes::TPCPATCH();
+    const LogicalType TGEOM = TPcpatchTypes::tpcpatch();
     const LogicalType TSTZ  = LogicalType::TIMESTAMP_TZ;
     const LogicalType IVAL  = LogicalType::INTERVAL;
 
@@ -1521,7 +1472,8 @@ void TPcpatchTypes::RegisterScalarFunctions(ExtensionLoader &loader) {
 }
 
 void TPcpatchTypes::RegisterTypes(ExtensionLoader &loader) {
-    loader.RegisterType( "TPCPATCH", TPcpatchTypes::TPCPATCH());
+    loader.RegisterType( "pcpatch", TPcpatchTypes::pcpatch());
+    loader.RegisterType( "tpcpatch", TPcpatchTypes::tpcpatch());
 }
 
 
diff --git a/src/pointcloud/tpcpatch_in_out.cpp b/src/pointcloud/tpcpatch_in_out.cpp
index fdef7326..904880d5 100644
--- a/src/pointcloud/tpcpatch_in_out.cpp
+++ b/src/pointcloud/tpcpatch_in_out.cpp
@@ -25,7 +25,7 @@ namespace duckdb {
 // schema-dependent EWKT path is not meaningful for a pgpointcloud value
 // without a registered PCSCHEMA — so this port does not register an
 // asText / asEWKT overload (no unverified-parity over-emission).  Text
-// I/O is provided by the VARCHAR <-> TPCPATCH cast below.
+// I/O is provided by the VARCHAR <-> tpcpatch cast below.
 
 bool TpcpatchFunctions::StringToTpcpatch(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
     UnaryExecutor::Execute<string_t, string_t>(
@@ -38,14 +38,14 @@ bool TpcpatchFunctions::StringToTpcpatch(Vector &source, Vector &result, idx_t c
             // MobilityDB SQL binds tpcpatch_in to.
             Temporal *temp = temporal_in(input_str.c_str(), T_TPCPATCH);
             if (!temp) {
-                throw InvalidInputException("Invalid TPCPATCH input: " + input_str);
+                throw InvalidInputException("Invalid tpcpatch input: " + input_str);
             }
 
             size_t data_size = temporal_mem_size(temp);
             uint8_t *data_buffer = (uint8_t*)malloc(data_size);
             if (!data_buffer) {
                 free(temp);
-                throw InvalidInputException("Failed to allocate memory for TPCPATCH data");
+                throw InvalidInputException("Failed to allocate memory for tpcpatch data");
             }
 
             memcpy(data_buffer, temp, data_size);
@@ -73,25 +73,25 @@ bool TpcpatchFunctions::TpcpatchToString(Vector &source, Vector &result, idx_t c
             size_t data_size = input_blob.GetSize();
 
             if (data_size < sizeof(void*)) {
-                throw InvalidInputException("Invalid TPCPATCH data: insufficient size");
+                throw InvalidInputException("Invalid tpcpatch data: insufficient size");
             }
 
             uint8_t *data_copy = (uint8_t*)malloc(data_size);
             if (!data_copy) {
-                throw InvalidInputException("Failed to allocate memory for TPCPATCH deserialization");
+                throw InvalidInputException("Failed to allocate memory for tpcpatch deserialization");
             }
             memcpy(data_copy, data, data_size);
 
             Temporal *temp = reinterpret_cast<Temporal*>(data_copy);
             if (!temp) {
                 free(data_copy);
-                throw InvalidInputException("Invalid TPCPATCH data: null pointer");
+                throw InvalidInputException("Invalid tpcpatch data: null pointer");
             }
 
             char *str = temporal_out(temp, 15);
             if (!str) {
                 free(data_copy);
-                throw InvalidInputException("Failed to convert TPCPATCH to string");
+                throw InvalidInputException("Failed to convert tpcpatch to string");
             }
 
             std::string output(str);
@@ -216,7 +216,7 @@ void TPcpatchTypes::RegisterScalarInOutFunctions(ExtensionLoader &loader){
     // ---- tpcpatchFromBinary / FromHexWKB / FromMFJSON / FromText ----
     const auto B = LogicalType::BLOB;
     const auto V = LogicalType::VARCHAR;
-    const auto T = TPcpatchTypes::TPCPATCH();
+    const auto T = TPcpatchTypes::tpcpatch();
     duckdb::RegisterSerializedScalarFunction(loader,
         ScalarFunction("tpcpatchFromBinary", {B}, T, TspatialFromWkbExec));
     duckdb::RegisterSerializedScalarFunction(loader,
@@ -256,8 +256,11 @@ void TPcpatchTypes::RegisterScalarInOutFunctions(ExtensionLoader &loader){
 
 
 void TPcpatchTypes::RegisterCastFunctions(ExtensionLoader &loader) {
-    loader.RegisterCastFunction( LogicalType::VARCHAR, TPcpatchTypes::TPCPATCH(), TpcpatchFunctions::StringToTpcpatch);
-    loader.RegisterCastFunction( TPcpatchTypes::TPCPATCH(), LogicalType::VARCHAR, TpcpatchFunctions::TpcpatchToString);
+    loader.RegisterCastFunction( LogicalType::VARCHAR, TPcpatchTypes::tpcpatch(), TpcpatchFunctions::StringToTpcpatch);
+    loader.RegisterCastFunction( TPcpatchTypes::tpcpatch(), LogicalType::VARCHAR, TpcpatchFunctions::TpcpatchToString);
+    // Base pcpatch value render cast: generated startValue/endValue return the pcpatch
+    // base value, rendered as hex-WKB text via pcpatch_hex_out (cbuffer sibling pattern).
+    loader.RegisterCastFunction( TPcpatchTypes::pcpatch(), LogicalType::VARCHAR, TpcpatchFunctions::Pcpatch_out_cast);
 }
 
 }
diff --git a/src/pointcloud/tpcpoint.cpp b/src/pointcloud/tpcpoint.cpp
index 3edaaa7a..8a2c1585 100644
--- a/src/pointcloud/tpcpoint.cpp
+++ b/src/pointcloud/tpcpoint.cpp
@@ -45,9 +45,15 @@ extern "C" {
 
 namespace duckdb {
 
-LogicalType TPcpointTypes::TPCPOINT() {
+LogicalType TPcpointTypes::pcpoint() {
     auto type = LogicalType(LogicalTypeId::BLOB);
-    type.SetAlias("TPCPOINT");
+    type.SetAlias("pcpoint");
+    return type;
+}
+
+LogicalType TPcpointTypes::tpcpoint() {
+    auto type = LogicalType(LogicalTypeId::BLOB);
+    type.SetAlias("tpcpoint");
     return type;
 }
 
@@ -69,7 +75,7 @@ static void Tpcpoint_constructor(DataChunk &args, ExpressionState &state, Vector
             // T_TPCPOINT).
             Temporal *tinst = temporal_in(input.c_str(), T_TPCPOINT);
             if (!tinst) {
-                throw InvalidInputException("Invalid TPCPOINT input: " + input);
+                throw InvalidInputException("Invalid tpcpoint input: " + input);
             }
 
             size_t data_size = temporal_mem_size(tinst);
@@ -77,7 +83,7 @@ static void Tpcpoint_constructor(DataChunk &args, ExpressionState &state, Vector
             uint8_t *data_buffer = (uint8_t*)malloc(data_size);
             if (!data_buffer) {
                 free(tinst);
-                throw InvalidInputException("Failed to allocate memory for TPCPOINT data");
+                throw InvalidInputException("Failed to allocate memory for tpcpoint data");
             }
 
             memcpy(data_buffer, tinst, data_size);
@@ -444,13 +450,13 @@ static void Temporal_to_tstzspan(DataChunk &args, ExpressionState &state, Vector
             Temporal *temp = reinterpret_cast<Temporal*>(const_cast<char*>(input.c_str()));
 
             if (!temp) {
-                throw InvalidInputException("Invalid TPCPOINT data: null pointer");
+                throw InvalidInputException("Invalid tpcpoint data: null pointer");
             }
 
             Span *timespan = temporal_to_tstzspan(temp);
 
             if (!timespan) {
-                throw InvalidInputException("Failed to extract timespan from TPCPOINT");
+                throw InvalidInputException("Failed to extract timespan from tpcpoint");
             }
 
             size_t span_size = sizeof(Span);
@@ -494,12 +500,12 @@ static void Temporal_to_tinstant(DataChunk &args, ExpressionState &state, Vector
             Temporal *temp = reinterpret_cast<Temporal*>(const_cast<char*>(input.c_str()));
 
             if (!temp) {
-                throw InvalidInputException("Invalid TPCPOINT data: null pointer");
+                throw InvalidInputException("Invalid tpcpoint data: null pointer");
             }
 
             TInstant *inst = temporal_as_tinstant(temp);
             if (!inst) {
-                throw InvalidInputException("Failed to convert TPCPOINT to TInstant");
+                throw InvalidInputException("Failed to convert tpcpoint to TInstant");
             }
 
             size_t inst_size = temporal_mem_size((Temporal*)inst);
@@ -544,7 +550,7 @@ static void Temporal_set_interp(DataChunk &args, ExpressionState &state, Vector
 
             Temporal *temp = reinterpret_cast<Temporal*>(const_cast<char*>(input.c_str()));
             if (!temp) {
-                throw InvalidInputException("Invalid TPCPOINT data: null pointer");
+                throw InvalidInputException("Invalid tpcpoint data: null pointer");
             }
 
             std::string interp_str = interp_str_t.GetString();
@@ -594,14 +600,14 @@ static void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &resu
 
             Temporal *temp1 = reinterpret_cast<Temporal*>(const_cast<char*>(tgeom1.c_str()));
             if (!temp1) {
-                throw InvalidInputException("Invalid TPCPOINT data: null pointer");
+                throw InvalidInputException("Invalid tpcpoint data: null pointer");
             }
 
             std::string tgeom2 = tgeom2_str_t.GetString();
 
             Temporal *temp2 = reinterpret_cast<Temporal*>(const_cast<char*>(tgeom2.c_str()));
             if (!temp2) {
-                throw InvalidInputException("Invalid TPCPOINT data: null pointer");
+                throw InvalidInputException("Invalid tpcpoint data: null pointer");
             }
 
             Temporal *result_temp = temporal_merge(temp1, temp2);
@@ -650,7 +656,7 @@ static void Temporal_subtype(DataChunk &args, ExpressionState &state, Vector &re
 
             Temporal *temp = reinterpret_cast<Temporal*>(const_cast<char*>(input.c_str()));
             if (!temp) {
-                throw InvalidInputException("Invalid TPCPOINT data: null pointer");
+                throw InvalidInputException("Invalid tpcpoint data: null pointer");
             }
 
             const char *subtype_str = temporal_subtype(temp);
@@ -686,7 +692,7 @@ static void Temporal_interp(DataChunk &args, ExpressionState &state, Vector &res
 
             Temporal *temp = reinterpret_cast<Temporal*>(const_cast<char*>(input.c_str()));
             if (!temp) {
-                throw InvalidInputException("Invalid TPCPOINT data: null pointer");
+                throw InvalidInputException("Invalid tpcpoint data: null pointer");
             }
 
 
@@ -719,7 +725,7 @@ static void Temporal_mem_size(DataChunk &args, ExpressionState &state, Vector &r
 
             Temporal *temp = reinterpret_cast<Temporal*>(const_cast<char*>(input.c_str()));
             if (!temp) {
-                throw InvalidInputException("Invalid TPCPOINT data: null pointer");
+                throw InvalidInputException("Invalid tpcpoint data: null pointer");
             }
 
             size_t mem_size = temporal_mem_size(temp);
@@ -784,75 +790,32 @@ static void Tinstant_value(DataChunk &args, ExpressionState &state, Vector &resu
 
 
 
-static void Temporal_start_value(DataChunk &args, ExpressionState &state, Vector &result) {
-    auto count = args.size();
-    auto &input_vec = args.data[0];
+/* Temporal_start_value/Temporal_end_value retired: startValue/endValue are now
+ * generated (return the pcpoint base value, rendered via the pcpoint->VARCHAR cast). */
 
+/* Base pcpoint value (BLOB-alias) -> VARCHAR render cast, mirroring the cbuffer
+ * sibling's Cbuffer_out_cast. The generated startValue/endValue return the pcpoint
+ * base value; DuckDB renders it through this cast via the schema-free pcpoint_hex_out
+ * (hex-WKB text), the same form the retired hand accessors produced. */
+bool TpcpointFunctions::Pcpoint_out_cast(
+    Vector &source, Vector &result, idx_t count, CastParameters &parameters)
+{
     UnaryExecutor::Execute<string_t, string_t>(
-        input_vec, result, count,
-        [&](string_t input_str) -> string_t {
-            std::string input = input_str.GetString();
-
-            Temporal *temp = reinterpret_cast<Temporal*>(const_cast<char*>(input.c_str()));
-
-            // temporal_start_value returns a freshly allocated copy of
-            // the pcpoint value (datum_copy), which the caller owns.
-            Datum start_datum = temporal_start_value(temp);
-
-            Pcpoint *pt = reinterpret_cast<Pcpoint*>(start_datum);
+        source, result, count,
+        [&](string_t blob) -> string_t {
+            size_t sz = blob.GetSize();
+            uint8_t *copy = (uint8_t *)malloc(sz);
+            memcpy(copy, blob.GetData(), sz);
+            Pcpoint *pt = reinterpret_cast<Pcpoint *>(copy);
             char *str = pcpoint_hex_out(pt, 15);
-            if (!str) {
-                free(pt);
-                throw InvalidInputException("Failed to convert pcpoint value to text");
-            }
-            std::string output(str);
-            string_t stored_result = StringVector::AddString(result, output);
-
-            free(str);
             free(pt);
-
-            return stored_result;
-        });
-
-    if (count == 1) {
-        result.SetVectorType(VectorType::CONSTANT_VECTOR);
-    }
-}
-
-
-static void Temporal_end_value(DataChunk &args, ExpressionState &state, Vector &result) {
-    auto count = args.size();
-    auto &input_vec = args.data[0];
-
-    UnaryExecutor::Execute<string_t, string_t>(
-        input_vec, result, count,
-        [&](string_t input_str) -> string_t {
-            std::string input = input_str.GetString();
-
-            Temporal *temp = reinterpret_cast<Temporal*>(const_cast<char*>(input.c_str()));
-
-            // temporal_end_value returns a freshly allocated copy of
-            // the pcpoint value (datum_copy), which the caller owns.
-            Datum end_datum = temporal_end_value(temp);
-
-            Pcpoint *pt = reinterpret_cast<Pcpoint*>(end_datum);
-            char *str = pcpoint_hex_out(pt, 15);
-            if (!str) {
-                free(pt);
+            if (!str)
                 throw InvalidInputException("Failed to convert pcpoint value to text");
-            }
-            std::string output(str);
-            string_t stored_result = StringVector::AddString(result, output);
-
+            std::string s(str);
             free(str);
-            free(pt);
-
-            return stored_result;
+            return StringVector::AddString(result, s);
         });
-
-    if (count == 1) {
-        result.SetVectorType(VectorType::CONSTANT_VECTOR);
-    }
+    return true;
 }
 
 static void Tpcpoint_pcid(DataChunk &args, ExpressionState &state, Vector &result) {
@@ -1071,12 +1034,12 @@ static void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector
             size_t data_size = input_geom_str.GetSize();
 
             if (data_size < sizeof(void*)) {
-                throw InvalidInputException("Invalid TPCPOINT data: insufficient size");
+                throw InvalidInputException("Invalid tpcpoint data: insufficient size");
             }
 
             uint8_t *data_copy = (uint8_t*)malloc(data_size);
             if (!data_copy) {
-                throw InvalidInputException("Failed to allocate memory for TPCPOINT deserialization");
+                throw InvalidInputException("Failed to allocate memory for tpcpoint deserialization");
             }
             memcpy(data_copy, data, data_size);
 
@@ -1084,7 +1047,7 @@ static void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector
 
             if (!temp) {
                 free(data_copy);
-                throw InvalidInputException("Invalid TPCPOINT data: null pointer");
+                throw InvalidInputException("Invalid tpcpoint data: null pointer");
             }
 
             TimestampTz meos_t = temp->t;
@@ -1107,87 +1070,87 @@ static void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector
 void TPcpointTypes::RegisterScalarFunctions(ExtensionLoader &loader) {
 
     auto tpcpoint_function = ScalarFunction(
-        "TPCPOINT",
+        "tpcpoint",
         {LogicalType::VARCHAR},
-        TPcpointTypes::TPCPOINT(),
+        TPcpointTypes::tpcpoint(),
         Tpcpoint_constructor
     );
     duckdb::RegisterSerializedScalarFunction(loader,  tpcpoint_function);
 
     auto tpcpoint_from_timestamp_function = ScalarFunction(
-        "TPCPOINT",
+        "tpcpoint",
         {LogicalType::VARCHAR, LogicalType::TIMESTAMP_TZ},
-        TPcpointTypes::TPCPOINT(),
+        TPcpointTypes::tpcpoint(),
         Tpcpointinst_constructor);
     duckdb::RegisterSerializedScalarFunction(loader,  tpcpoint_from_timestamp_function);
 
      auto tpcpoint_from_tstzspan_function = ScalarFunction(
-        "TPCPOINT",
+        "tpcpoint",
         {LogicalType::VARCHAR, SpanTypes::tstzspan(), LogicalType::VARCHAR},
-        TPcpointTypes::TPCPOINT(),
+        TPcpointTypes::tpcpoint(),
         Tpcpoint_sequence_from_tstzspan
     );
     duckdb::RegisterSerializedScalarFunction(loader,  tpcpoint_from_tstzspan_function);
 
     auto tpcpoint_from_tstzspan_default = ScalarFunction(
-        "TPCPOINT",
+        "tpcpoint",
         {LogicalType::VARCHAR, SpanTypes::tstzspan()},
-        TPcpointTypes::TPCPOINT(),
+        TPcpointTypes::tpcpoint(),
         Tpcpoint_sequence_from_tstzspan
     );
     duckdb::RegisterSerializedScalarFunction(loader,  tpcpoint_from_tstzspan_default);
 
      auto tpcpointseqarr_1param= ScalarFunction(
         "tpcpointSeq",
-        {LogicalType::LIST(TPcpointTypes::TPCPOINT())},
-        TPcpointTypes::TPCPOINT(),
+        {LogicalType::LIST(TPcpointTypes::tpcpoint())},
+        TPcpointTypes::tpcpoint(),
         Tpcpoint_sequence_constructor
     );
     duckdb::RegisterSerializedScalarFunction(loader,  tpcpointseqarr_1param);
 
     auto tpcpointseqarr_2params = ScalarFunction(
         "tpcpointSeq",
-        {LogicalType::LIST(TPcpointTypes::TPCPOINT()), LogicalType::VARCHAR},
-        TPcpointTypes::TPCPOINT(),
+        {LogicalType::LIST(TPcpointTypes::tpcpoint()), LogicalType::VARCHAR},
+        TPcpointTypes::tpcpoint(),
         Tpcpoint_sequence_constructor
     );
     duckdb::RegisterSerializedScalarFunction(loader,  tpcpointseqarr_2params);
 
     auto tpcpointseqarr_3params = ScalarFunction(
         "tpcpointSeq",
-        {LogicalType::LIST(TPcpointTypes::TPCPOINT()), LogicalType::VARCHAR, LogicalType::BOOLEAN},
-        TPcpointTypes::TPCPOINT(),
+        {LogicalType::LIST(TPcpointTypes::tpcpoint()), LogicalType::VARCHAR, LogicalType::BOOLEAN},
+        TPcpointTypes::tpcpoint(),
         Tpcpoint_sequence_constructor
     );
     duckdb::RegisterSerializedScalarFunction(loader,  tpcpointseqarr_3params);
 
     auto tpcpointseqarr_4params = ScalarFunction(
         "tpcpointSeq",
-        {LogicalType::LIST(TPcpointTypes::TPCPOINT()), LogicalType::VARCHAR, LogicalType::BOOLEAN, LogicalType::BOOLEAN},
-        TPcpointTypes::TPCPOINT(),
+        {LogicalType::LIST(TPcpointTypes::tpcpoint()), LogicalType::VARCHAR, LogicalType::BOOLEAN, LogicalType::BOOLEAN},
+        TPcpointTypes::tpcpoint(),
         Tpcpoint_sequence_constructor
     );
     duckdb::RegisterSerializedScalarFunction(loader,  tpcpointseqarr_4params);
 
     auto tpcpoint_to_timespan_function = ScalarFunction(
         "timeSpan",
-        {TPcpointTypes::TPCPOINT()},
+        {TPcpointTypes::tpcpoint()},
         SpanTypes::tstzspan(),
         Temporal_to_tstzspan);
     duckdb::RegisterSerializedScalarFunction(loader,  tpcpoint_to_timespan_function);
 
     auto tpcpoint_to_tinstant_function = ScalarFunction(
         "tpcpointInst",
-        {TPcpointTypes::TPCPOINT()},
-        TPcpointTypes::TPCPOINT(),
+        {TPcpointTypes::tpcpoint()},
+        TPcpointTypes::tpcpoint(),
         Temporal_to_tinstant);
     duckdb::RegisterSerializedScalarFunction(loader,  tpcpoint_to_tinstant_function);
 
 
     auto setInterp_function = ScalarFunction(
         "setInterp",
-        {TPcpointTypes::TPCPOINT(), LogicalType::VARCHAR},
-        TPcpointTypes::TPCPOINT(),
+        {TPcpointTypes::tpcpoint(), LogicalType::VARCHAR},
+        TPcpointTypes::tpcpoint(),
         Temporal_set_interp
     );
     duckdb::RegisterSerializedScalarFunction(loader,  setInterp_function);
@@ -1195,15 +1158,15 @@ void TPcpointTypes::RegisterScalarFunctions(ExtensionLoader &loader) {
 
     auto merge_function = ScalarFunction(
         "merge",
-        {TPcpointTypes::TPCPOINT(), TPcpointTypes::TPCPOINT()},
-        TPcpointTypes::TPCPOINT(),
+        {TPcpointTypes::tpcpoint(), TPcpointTypes::tpcpoint()},
+        TPcpointTypes::tpcpoint(),
         Temporal_merge
     );
     duckdb::RegisterSerializedScalarFunction(loader,  merge_function);
 
     auto tempSubtype_function = ScalarFunction(
         "tempSubtype",
-        {TPcpointTypes::TPCPOINT()},
+        {TPcpointTypes::tpcpoint()},
         LogicalType::VARCHAR,
         Temporal_subtype
     );
@@ -1211,7 +1174,7 @@ void TPcpointTypes::RegisterScalarFunctions(ExtensionLoader &loader) {
 
     auto interp_function = ScalarFunction(
         "interp",
-        {TPcpointTypes::TPCPOINT()},
+        {TPcpointTypes::tpcpoint()},
         LogicalType::VARCHAR,
         Temporal_interp
     );
@@ -1219,7 +1182,7 @@ void TPcpointTypes::RegisterScalarFunctions(ExtensionLoader &loader) {
 
     auto memSize_function = ScalarFunction(
         "memSize",
-        {TPcpointTypes::TPCPOINT()},
+        {TPcpointTypes::tpcpoint()},
         LogicalType::INTEGER,
         Temporal_mem_size
     );
@@ -1227,32 +1190,20 @@ void TPcpointTypes::RegisterScalarFunctions(ExtensionLoader &loader) {
 
     auto getValue_function = ScalarFunction(
         "getValue",
-        {TPcpointTypes::TPCPOINT()},
+        {TPcpointTypes::tpcpoint()},
         LogicalType::VARCHAR,
         Tinstant_value
     );
     duckdb::RegisterSerializedScalarFunction(loader,  getValue_function);
 
 
-    auto tpcpoint_start_value_function = ScalarFunction(
-        "startValue",
-        {TPcpointTypes::TPCPOINT()},
-        LogicalType::VARCHAR,
-        Temporal_start_value
-    );
-    duckdb::RegisterSerializedScalarFunction(loader,  tpcpoint_start_value_function);
-
-    auto tpcpoint_end_value_function = ScalarFunction(
-        "endValue",
-        {TPcpointTypes::TPCPOINT()},
-        LogicalType::VARCHAR,
-        Temporal_end_value
-    );
-    duckdb::RegisterSerializedScalarFunction(loader,  tpcpoint_end_value_function);
+    /* startValue/endValue are now GENERATED (they return the pcpoint base value,
+     * rendered as hex-WKB text via the pcpoint->VARCHAR cast), mirroring the cbuffer
+     * sibling; the hand VARCHAR registrations are retired to avoid an ambiguous overload. */
 
     auto tpcpoint_pcid_function = ScalarFunction(
         "pcid",
-        {TPcpointTypes::TPCPOINT()},
+        {TPcpointTypes::tpcpoint()},
         LogicalType::INTEGER,
         Tpcpoint_pcid
     );
@@ -1260,24 +1211,24 @@ void TPcpointTypes::RegisterScalarFunctions(ExtensionLoader &loader) {
 
     auto startInstant_function = ScalarFunction(
         "startInstant",
-        {TPcpointTypes::TPCPOINT()},
-        TPcpointTypes::TPCPOINT(),
+        {TPcpointTypes::tpcpoint()},
+        TPcpointTypes::tpcpoint(),
         Temporal_start_instant
     );
     duckdb::RegisterSerializedScalarFunction(loader,  startInstant_function);
 
     auto endInstant_function = ScalarFunction(
         "endInstant",
-        {TPcpointTypes::TPCPOINT()},
-        TPcpointTypes::TPCPOINT(),
+        {TPcpointTypes::tpcpoint()},
+        TPcpointTypes::tpcpoint(),
         Temporal_end_instant
     );
     duckdb::RegisterSerializedScalarFunction(loader,  endInstant_function);
 
     auto instantN_function = ScalarFunction(
         "instantN",
-        {TPcpointTypes::TPCPOINT(), LogicalType::INTEGER},
-        TPcpointTypes::TPCPOINT(),
+        {TPcpointTypes::tpcpoint(), LogicalType::INTEGER},
+        TPcpointTypes::tpcpoint(),
         Temporal_instant_n
     );
     duckdb::RegisterSerializedScalarFunction(loader,  instantN_function);
@@ -1285,7 +1236,7 @@ void TPcpointTypes::RegisterScalarFunctions(ExtensionLoader &loader) {
 
     auto tpcpoint_gettimestamptz_function = ScalarFunction(
         "getTimestamp",
-        {TPcpointTypes::TPCPOINT()},
+        {TPcpointTypes::tpcpoint()},
         LogicalType::TIMESTAMP_TZ,
         Tinstant_timestamptz);
     duckdb::RegisterSerializedScalarFunction(loader,  tpcpoint_gettimestamptz_function);
@@ -1298,7 +1249,7 @@ void TPcpointTypes::RegisterScalarFunctions(ExtensionLoader &loader) {
     // generic handlers wired for tgeompoint in temporal_functions.cpp.
     // ===================================================================
 
-    const LogicalType TGEOM = TPcpointTypes::TPCPOINT();
+    const LogicalType TGEOM = TPcpointTypes::tpcpoint();
     const LogicalType TSTZ  = LogicalType::TIMESTAMP_TZ;
     const LogicalType IVAL  = LogicalType::INTERVAL;
 
@@ -1475,7 +1426,8 @@ void TPcpointTypes::RegisterScalarFunctions(ExtensionLoader &loader) {
 }
 
 void TPcpointTypes::RegisterTypes(ExtensionLoader &loader) {
-    loader.RegisterType( "TPCPOINT", TPcpointTypes::TPCPOINT());
+    loader.RegisterType( "pcpoint", TPcpointTypes::pcpoint());
+    loader.RegisterType( "tpcpoint", TPcpointTypes::tpcpoint());
 }
 
 
diff --git a/src/pointcloud/tpcpoint_in_out.cpp b/src/pointcloud/tpcpoint_in_out.cpp
index 8c77c6bf..d726a6e6 100644
--- a/src/pointcloud/tpcpoint_in_out.cpp
+++ b/src/pointcloud/tpcpoint_in_out.cpp
@@ -25,7 +25,7 @@ namespace duckdb {
 // schema-dependent EWKT path is not meaningful for a pgpointcloud value
 // without a registered PCSCHEMA — so this port does not register an
 // asText / asEWKT overload (no unverified-parity over-emission).  Text
-// I/O is provided by the VARCHAR <-> TPCPOINT cast below.
+// I/O is provided by the VARCHAR <-> tpcpoint cast below.
 
 bool TpcpointFunctions::StringToTpcpoint(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
     UnaryExecutor::Execute<string_t, string_t>(
@@ -38,14 +38,14 @@ bool TpcpointFunctions::StringToTpcpoint(Vector &source, Vector &result, idx_t c
             // MobilityDB SQL binds tpcpoint_in to.
             Temporal *temp = temporal_in(input_str.c_str(), T_TPCPOINT);
             if (!temp) {
-                throw InvalidInputException("Invalid TPCPOINT input: " + input_str);
+                throw InvalidInputException("Invalid tpcpoint input: " + input_str);
             }
 
             size_t data_size = temporal_mem_size(temp);
             uint8_t *data_buffer = (uint8_t*)malloc(data_size);
             if (!data_buffer) {
                 free(temp);
-                throw InvalidInputException("Failed to allocate memory for TPCPOINT data");
+                throw InvalidInputException("Failed to allocate memory for tpcpoint data");
             }
 
             memcpy(data_buffer, temp, data_size);
@@ -73,25 +73,25 @@ bool TpcpointFunctions::TpcpointToString(Vector &source, Vector &result, idx_t c
             size_t data_size = input_blob.GetSize();
 
             if (data_size < sizeof(void*)) {
-                throw InvalidInputException("Invalid TPCPOINT data: insufficient size");
+                throw InvalidInputException("Invalid tpcpoint data: insufficient size");
             }
 
             uint8_t *data_copy = (uint8_t*)malloc(data_size);
             if (!data_copy) {
-                throw InvalidInputException("Failed to allocate memory for TPCPOINT deserialization");
+                throw InvalidInputException("Failed to allocate memory for tpcpoint deserialization");
             }
             memcpy(data_copy, data, data_size);
 
             Temporal *temp = reinterpret_cast<Temporal*>(data_copy);
             if (!temp) {
                 free(data_copy);
-                throw InvalidInputException("Invalid TPCPOINT data: null pointer");
+                throw InvalidInputException("Invalid tpcpoint data: null pointer");
             }
 
             char *str = temporal_out(temp, 15);
             if (!str) {
                 free(data_copy);
-                throw InvalidInputException("Failed to convert TPCPOINT to string");
+                throw InvalidInputException("Failed to convert tpcpoint to string");
             }
 
             std::string output(str);
@@ -218,7 +218,7 @@ void TPcpointTypes::RegisterScalarInOutFunctions(ExtensionLoader &loader){
     // ---- tpcpointFromBinary / FromHexWKB / FromMFJSON / FromText ----
     const auto B = LogicalType::BLOB;
     const auto V = LogicalType::VARCHAR;
-    const auto T = TPcpointTypes::TPCPOINT();
+    const auto T = TPcpointTypes::tpcpoint();
     duckdb::RegisterSerializedScalarFunction(loader,
         ScalarFunction("tpcpointFromBinary", {B}, T, TspatialFromWkbExec));
     duckdb::RegisterSerializedScalarFunction(loader,
@@ -258,8 +258,11 @@ void TPcpointTypes::RegisterScalarInOutFunctions(ExtensionLoader &loader){
 
 
 void TPcpointTypes::RegisterCastFunctions(ExtensionLoader &loader) {
-    loader.RegisterCastFunction( LogicalType::VARCHAR, TPcpointTypes::TPCPOINT(), TpcpointFunctions::StringToTpcpoint);
-    loader.RegisterCastFunction( TPcpointTypes::TPCPOINT(), LogicalType::VARCHAR, TpcpointFunctions::TpcpointToString);
+    loader.RegisterCastFunction( LogicalType::VARCHAR, TPcpointTypes::tpcpoint(), TpcpointFunctions::StringToTpcpoint);
+    loader.RegisterCastFunction( TPcpointTypes::tpcpoint(), LogicalType::VARCHAR, TpcpointFunctions::TpcpointToString);
+    // Base pcpoint value render cast: generated startValue/endValue return the pcpoint
+    // base value, rendered as hex-WKB text via pcpoint_hex_out (cbuffer sibling pattern).
+    loader.RegisterCastFunction( TPcpointTypes::pcpoint(), LogicalType::VARCHAR, TpcpointFunctions::Pcpoint_out_cast);
 }
 
 }
diff --git a/tools/codegen_duck_udfs.py b/tools/codegen_duck_udfs.py
index 75957bf7..3f6469da 100644
--- a/tools/codegen_duck_udfs.py
+++ b/tools/codegen_duck_udfs.py
@@ -45,6 +45,8 @@ def base(canon):
     "TBox":         ("LogicalType::BLOB", "BlobToTbox(%s)"),
     "Cbuffer":      ("CbufferTypes::cbuffer()", "BlobToCbuffer(%s)"),
     "Jsonb":        ("TJsonbTypes::jsonb()", "BlobToJsonb(%s)"),
+    "Pcpoint":      ("TPcpointTypes::pcpoint()", "BlobToPcpoint(%s)"),
+    "Pcpatch":      ("TPcpatchTypes::pcpatch()", "BlobToPcpatch(%s)"),
 }
 PTR_RET = {  # MEOS base type -> (DuckDB ret LogicalType, "C++ expr producing string_t from MEOS ptr `%s` in `result`")
     "Temporal":     ("MD_TEMPORAL", "TemporalToBlob(result, %s)"),
@@ -58,6 +60,8 @@ def base(canon):
     "TBox":         ("LogicalType::BLOB", "TboxToBlob(result, %s)"),
     "Cbuffer":      ("CbufferTypes::cbuffer()", "CbufferToBlob(result, %s)"),
     "Jsonb":        ("TJsonbTypes::jsonb()", "JsonbToBlob(result, %s)"),
+    "Pcpoint":      ("TPcpointTypes::pcpoint()", "PcpointToBlob(result, %s)"),
+    "Pcpatch":      ("TPcpatchTypes::pcpatch()", "PcpatchToBlob(result, %s)"),
 }
 # The temporal-family pointer returns that marshal as one DuckDB temporal handle. A MEOS
 # accessor/cast can return a concrete subtype pointer (TInstant */TSequence */TSequenceSet *
@@ -178,6 +182,7 @@ def ret_type(f, out_canon):
     "tgeompoint", "tgeogpoint", "tgeometry", "tgeography", "tgeo", "tspatial", "tquadbin",
     "tcbuffer", "cbuffer", "th3index", "h3index",
     "tjsonb", "jsonb",
+    "tpcpoint", "pcpoint", "tpcpatch", "pcpatch",
 }
 # Every temporal family token the catalog function names use; those NOT in REGISTERED_FAMILIES
 # are the fast-follow families whose DuckDB type the binding does not register yet.
@@ -434,6 +439,14 @@ def reg_scope(name):
     # temporal, transforms) emits here.
     if name.startswith("tjsonb_") or re.search(r'_tjsonb(?=_|$)', name):
         return ("types", ["TJsonbTypes::tjsonb()"])
+    # the temporal pointcloud families (their own gated types): a tpcpoint_*/tpcpatch_*
+    # prefix, or a _tpcpoint/_tpcpatch token anywhere. The base pcpoint/pcpatch-value-coupled
+    # accessors marshal via the Pcpoint/Pcpatch varlena marshaller; geometry-coupled variants
+    # auto-exclude on their unmarshallable arg/return.
+    if name.startswith("tpcpoint_") or re.search(r'_tpcpoint(?=_|$)', name):
+        return ("types", ["TPcpointTypes::tpcpoint()"])
+    if name.startswith("tpcpatch_") or re.search(r'_tpcpatch(?=_|$)', name):
+        return ("types", ["TPcpatchTypes::tpcpatch()"])
     # temporal-type token ANYWHERE in the name (always_eq_tint_int, ever_lt_tfloat_tfloat,
     # tdistance_tfloat_tfloat, teq_temporal_temporal). Skip if >1 DISTINCT temporal type
     # appears (mixed/ambiguous) — geo tokens (tgeompoint/tgeo/th3index/tnpoint) aren't in
@@ -457,7 +470,8 @@ def reg_scope(name):
            "tgeometry": "TGeometryTypes::tgeometry()", "tgeography": "TGeographyTypes::tgeography()",
            "tgeompoint": "TgeompointType::tgeompoint()", "tgeogpoint": "TgeogpointType::tgeogpoint()",
            "tcbuffer": "CbufferTypes::tcbuffer()", "th3index": "H3indexTypes::th3index()",
-           "tquadbin": "QuadbinTypes::tquadbin()", "tjsonb": "TJsonbTypes::tjsonb()"}
+           "tquadbin": "QuadbinTypes::tquadbin()", "tjsonb": "TJsonbTypes::tjsonb()",
+           "tpcpoint": "TPcpointTypes::tpcpoint()", "tpcpatch": "TPcpatchTypes::tpcpatch()"}
 def ret_temporal_type(name, arg_acc, group="", sql_ret=None):
     # A single, unambiguous SQL return subtype from the catalog names the output
     # temporal type directly (the catalog is the SoT). The name heuristics below are
@@ -495,6 +509,7 @@ def ret_temporal_type(name, arg_acc, group="", sql_ret=None):
     "tgeometry":  "TGeometryTypes::tgeometry()",  "tgeography": "TGeographyTypes::tgeography()",
     "tcbuffer":   "CbufferTypes::tcbuffer()",      "th3index":   "H3indexTypes::th3index()",
     "tquadbin":   "QuadbinTypes::tquadbin()",      "tjsonb":     "TJsonbTypes::tjsonb()",
+    "tpcpoint":   "TPcpointTypes::tpcpoint()",     "tpcpatch":   "TPcpatchTypes::tpcpatch()",
 }
 def sig_declared_accs(f):
     """The exact temporal-operand types this GENERIC (`Temporal *`) function is CREATE
@@ -3045,12 +3060,15 @@ def gen_cpp(fns, out_path, declared=None, aliases=None):
            '#include "h3/th3index.hpp"\n'              # H3indexTypes::h3index()/th3index()
            '#include "quadbin/tquadbin.hpp"\n'         # QuadbinTypes::quadbin()/tquadbin()
            '#include "json/tjsonb.hpp"\n'              # TJsonbTypes::jsonb()/tjsonb()
+           '#include "pointcloud/tpcpoint.hpp"\n'      # TPcpointTypes::pcpoint()/tpcpoint()
+           '#include "pointcloud/tpcpatch.hpp"\n'      # TPcpatchTypes::pcpatch()/tpcpatch()
            '#include "spatial/spatial_types.hpp"\n'   # GeoTypes::GEOMETRY() (duckdb-spatial)
            '#include "geo_util.hpp"\n'                # GeometryToGSerialized(blob, srid)
            '#include "meos_internal.h"\n'
            '#include "meos_geo.h"\n'
            '#include "meos_internal_geo.h"\n'
            '#include "meos_json.h"\n'                  # Jsonb type (via pgtypes.h) + tjsonb_*/jsonb_* fns
+           '#include "meos_pointcloud.h"\n'            # Pcpoint/Pcpatch types + tpcpoint/tpcpatch fns
            '#include "time_util.hpp"\n'
            '#include "mobilityduck/meos_exec_serial.hpp"\n'
            '#include "duckdb/function/scalar_function.hpp"\n'
@@ -3138,6 +3156,28 @@ def gen_cpp(fns, out_path, declared=None, aliases=None):
            "    uint8_t *copy = (uint8_t *)malloc(sz);\n"
            "    memcpy(copy, blob.GetData(), sz);\n"
            "    return reinterpret_cast<Jsonb *>(copy);\n}\n"
+           "// Self-contained blob<->Pcpoint/Pcpatch marshalling. Both are varlena (vl_len_\n"
+           "// header) -> VARSIZE out; the stored BLOB is the raw bytes (mirror Cbuffer).\n"
+           "inline string_t PcpointToBlob(Vector &result, Pcpoint *pt) {\n"
+           "    string_t out = StringVector::AddStringOrBlob(result, (const char *)pt, VARSIZE(pt));\n"
+           "    free(pt);\n    return out;\n}\n"
+           "inline string_t PcpointToBlobN(Vector &result, Pcpoint *pt, ValidityMask &mask, idx_t idx) {\n"
+           "    if (!pt) { mask.SetInvalid(idx); return string_t(); }\n    return PcpointToBlob(result, pt);\n}\n"
+           "inline Pcpoint *BlobToPcpoint(string_t blob) {\n"
+           "    size_t sz = blob.GetSize();\n"
+           "    uint8_t *copy = (uint8_t *)malloc(sz);\n"
+           "    memcpy(copy, blob.GetData(), sz);\n"
+           "    return reinterpret_cast<Pcpoint *>(copy);\n}\n"
+           "inline string_t PcpatchToBlob(Vector &result, Pcpatch *pa) {\n"
+           "    string_t out = StringVector::AddStringOrBlob(result, (const char *)pa, VARSIZE(pa));\n"
+           "    free(pa);\n    return out;\n}\n"
+           "inline string_t PcpatchToBlobN(Vector &result, Pcpatch *pa, ValidityMask &mask, idx_t idx) {\n"
+           "    if (!pa) { mask.SetInvalid(idx); return string_t(); }\n    return PcpatchToBlob(result, pa);\n}\n"
+           "inline Pcpatch *BlobToPcpatch(string_t blob) {\n"
+           "    size_t sz = blob.GetSize();\n"
+           "    uint8_t *copy = (uint8_t *)malloc(sz);\n"
+           "    memcpy(copy, blob.GetData(), sz);\n"
+           "    return reinterpret_cast<Pcpatch *>(copy);\n}\n"
            "// Self-contained blob<->STBox/TBox marshalling (FIXED-size structs -> sizeof).\n"
            "inline string_t StboxToBlob(Vector &result, STBox *b) {\n"
            "    string_t out = StringVector::AddStringOrBlob(result, (const char *)b, sizeof(STBox));\n"
diff --git a/vcpkg_ports/meos/vcpkg.json b/vcpkg_ports/meos/vcpkg.json
index 61bf49f2..d1cb5854 100644
--- a/vcpkg_ports/meos/vcpkg.json
+++ b/vcpkg_ports/meos/vcpkg.json
@@ -1,7 +1,7 @@
 {
     "name": "meos",
     "version-string": "git",
-    "port-version": 11,
+    "port-version": 12,
     "description": "MEOS - Mobility Engine Open Source C library (built from MobilityDB with -DMEOS=ON)",
     "homepage": "https://libmeos.org/",
     "dependencies": [