WIP: Port to serd1

1 files changed, 286 insertions, 341 deletions

diff --git a/src/world.c b/src/world.c
index 47dc147..31fa906 100644
--- a/src/world.c
+++ b/src/world.c
@@ -19,14 +19,13 @@
 #include "lilv_internal.h"
 
 #include "lilv/lilv.h"
+#include "lv2/core/lv2.h"
+#include "lv2/presets/presets.h"
+#include "lv2/state/state.h"
 #include "serd/serd.h"
-#include "sord/sord.h"
 #include "zix/common.h"
 #include "zix/tree.h"
 
-#include "lv2/core/lv2.h"
-#include "lv2/presets/presets.h"
-
 #ifdef LILV_DYN_MANIFEST
 #  include "lv2/dynmanifest/dynmanifest.h"
 #  include <dlfcn.h>
@@ -34,25 +33,25 @@
 
 #include <assert.h>
 #include <stdbool.h>
-#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 static int
-lilv_world_drop_graph(LilvWorld* world, const SordNode* graph);
+lilv_world_drop_graph(LilvWorld* world, const SerdNode* graph);
 
 LilvWorld*
 lilv_world_new(void)
 {
   LilvWorld* world = (LilvWorld*)calloc(1, sizeof(LilvWorld));
 
-  world->world = sord_world_new();
+  world->world = serd_world_new();
   if (!world->world) {
     goto fail;
   }
 
-  world->model = sord_new(world->world, SORD_SPO | SORD_OPS, true);
+  world->model = serd_model_new(
+    world->world, SERD_INDEX_SPO | SERD_INDEX_OPS | SERD_INDEX_GRAPHS);
   if (!world->model) {
     goto fail;
   }
@@ -70,7 +69,7 @@ lilv_world_new(void)
 #define NS_DYNMAN "http://lv2plug.in/ns/ext/dynmanifest#"
 #define NS_OWL "http://www.w3.org/2002/07/owl#"
 
-#define NEW_URI(uri) sord_new_uri(world->world, (const uint8_t*)(uri))
+#define NEW_URI(uri) serd_new_uri(SERD_STATIC_STRING(uri))
 
   world->uris.dc_replaces         = NEW_URI(NS_DCTERMS "replaces");
   world->uris.dman_DynManifest    = NEW_URI(NS_DYNMAN "DynManifest");
@@ -94,9 +93,11 @@ lilv_world_new(void)
   world->uris.lv2_portProperty    = NEW_URI(LV2_CORE__portProperty);
   world->uris.lv2_reportsLatency  = NEW_URI(LV2_CORE__reportsLatency);
   world->uris.lv2_requiredFeature = NEW_URI(LV2_CORE__requiredFeature);
-  world->uris.lv2_symbol          = NEW_URI(LV2_CORE__symbol);
+  world->uris.lv2_project         = NEW_URI(LV2_CORE__project);
   world->uris.lv2_prototype       = NEW_URI(LV2_CORE__prototype);
+  world->uris.lv2_symbol          = NEW_URI(LV2_CORE__symbol);
   world->uris.owl_Ontology        = NEW_URI(NS_OWL "Ontology");
+  world->uris.pset_Preset         = NEW_URI(LV2_PRESETS__Preset);
   world->uris.pset_value          = NEW_URI(LV2_PRESETS__value);
   world->uris.rdf_a               = NEW_URI(LILV_NS_RDF "type");
   world->uris.rdf_value           = NEW_URI(LILV_NS_RDF "value");
@@ -104,10 +105,12 @@ lilv_world_new(void)
   world->uris.rdfs_label          = NEW_URI(LILV_NS_RDFS "label");
   world->uris.rdfs_seeAlso        = NEW_URI(LILV_NS_RDFS "seeAlso");
   world->uris.rdfs_subClassOf     = NEW_URI(LILV_NS_RDFS "subClassOf");
+  world->uris.state_state         = NEW_URI(LV2_STATE__state);
   world->uris.xsd_base64Binary    = NEW_URI(LILV_NS_XSD "base64Binary");
   world->uris.xsd_boolean         = NEW_URI(LILV_NS_XSD "boolean");
   world->uris.xsd_decimal         = NEW_URI(LILV_NS_XSD "decimal");
   world->uris.xsd_double          = NEW_URI(LILV_NS_XSD "double");
+  world->uris.xsd_int             = NEW_URI(LILV_NS_XSD "int");
   world->uris.xsd_integer         = NEW_URI(LILV_NS_XSD "integer");
   world->uris.null_uri            = NULL;
 
@@ -136,14 +139,14 @@ lilv_world_free(LilvWorld* world)
   lilv_plugin_class_free(world->lv2_plugin_class);
   world->lv2_plugin_class = NULL;
 
-  for (SordNode** n = (SordNode**)&world->uris; *n; ++n) {
-    sord_node_free(world->world, *n);
+  for (SerdNode** n = (SerdNode**)&world->uris; *n; ++n) {
+    serd_node_free(*n);
   }
 
   for (LilvSpec* spec = world->specs; spec;) {
     LilvSpec* next = spec->next;
-    sord_node_free(world->world, spec->spec);
-    sord_node_free(world->world, spec->bundle);
+    serd_node_free(spec->spec);
+    serd_node_free(spec->bundle);
     lilv_nodes_free(spec->data_uris);
     free(spec);
     spec = next;
@@ -173,10 +176,10 @@ lilv_world_free(LilvWorld* world)
   zix_tree_free((ZixTree*)world->plugin_classes);
   world->plugin_classes = NULL;
 
-  sord_free(world->model);
+  serd_model_free(world->model);
   world->model = NULL;
 
-  sord_world_free(world->world);
+  serd_world_free(world->world);
   world->world = NULL;
 
   free(world->opt.lv2_path);
@@ -212,31 +215,20 @@ lilv_world_find_nodes(LilvWorld*      world,
                       const LilvNode* object)
 {
   if (subject && !lilv_node_is_uri(subject) && !lilv_node_is_blank(subject)) {
-    LILV_ERRORF("Subject `%s' is not a resource\n",
-                sord_node_get_string(subject->node));
+    LILV_ERRORF("Subject `%s' is not a resource\n", serd_node_string(subject));
     return NULL;
-  }
-
-  if (!predicate) {
+  } else if (!predicate) {
     LILV_ERROR("Missing required predicate\n");
     return NULL;
-  }
-
-  if (!lilv_node_is_uri(predicate)) {
-    LILV_ERRORF("Predicate `%s' is not a URI\n",
-                sord_node_get_string(predicate->node));
+  } else if (!lilv_node_is_uri(predicate)) {
+    LILV_ERRORF("Predicate `%s' is not a URI\n", serd_node_string(predicate));
     return NULL;
-  }
-
-  if (!subject && !object) {
+  } else if (!subject && !object) {
     LILV_ERROR("Both subject and object are NULL\n");
     return NULL;
   }
 
-  return lilv_world_find_nodes_internal(world,
-                                        subject ? subject->node : NULL,
-                                        predicate->node,
-                                        object ? object->node : NULL);
+  return lilv_world_find_nodes_internal(world, subject, predicate, object);
 }
 
 LilvNode*
@@ -245,52 +237,8 @@ lilv_world_get(LilvWorld*      world,
                const LilvNode* predicate,
                const LilvNode* object)
 {
-  if (!object) {
-    // TODO: Improve performance (see lilv_plugin_get_one)
-    SordIter* stream = sord_search(world->model,
-                                   subject ? subject->node : NULL,
-                                   predicate ? predicate->node : NULL,
-                                   NULL,
-                                   NULL);
-
-    LilvNodes* nodes =
-      lilv_nodes_from_stream_objects(world, stream, SORD_OBJECT);
-
-    if (nodes) {
-      LilvNode* value = lilv_node_duplicate(lilv_nodes_get_first(nodes));
-      lilv_nodes_free(nodes);
-      return value;
-    }
-
-    return NULL;
-  }
-
-  SordNode* snode = sord_get(world->model,
-                             subject ? subject->node : NULL,
-                             predicate ? predicate->node : NULL,
-                             object ? object->node : NULL,
-                             NULL);
-  LilvNode* lnode = lilv_node_new_from_node(world, snode);
-  sord_node_free(world->world, snode);
-  return lnode;
-}
-
-SordIter*
-lilv_world_query_internal(LilvWorld*      world,
-                          const SordNode* subject,
-                          const SordNode* predicate,
-                          const SordNode* object)
-{
-  return sord_search(world->model, subject, predicate, object, NULL);
-}
-
-bool
-lilv_world_ask_internal(LilvWorld*      world,
-                        const SordNode* subject,
-                        const SordNode* predicate,
-                        const SordNode* object)
-{
-  return sord_ask(world->model, subject, predicate, object, NULL);
+  return serd_node_copy(
+    serd_model_get(world->model, subject, predicate, object, NULL));
 }
 
 bool
@@ -299,59 +247,44 @@ lilv_world_ask(LilvWorld*      world,
                const LilvNode* predicate,
                const LilvNode* object)
 {
-  return sord_ask(world->model,
-                  subject ? subject->node : NULL,
-                  predicate ? predicate->node : NULL,
-                  object ? object->node : NULL,
-                  NULL);
+  return serd_model_ask(world->model, subject, predicate, object, NULL);
 }
 
-SordModel*
+SerdModel*
 lilv_world_filter_model(LilvWorld*      world,
-                        SordModel*      model,
-                        const SordNode* subject,
-                        const SordNode* predicate,
-                        const SordNode* object,
-                        const SordNode* graph)
+                        SerdModel*      model,
+                        const SerdNode* subject,
+                        const SerdNode* predicate,
+                        const SerdNode* object,
+                        const SerdNode* graph)
 {
-  SordModel* results = sord_new(world->world, SORD_SPO, false);
-  SordIter*  i       = sord_search(model, subject, predicate, object, graph);
-  for (; !sord_iter_end(i); sord_iter_next(i)) {
-    SordQuad quad;
-    sord_iter_get(i, quad);
-    sord_add(results, quad);
+  SerdModel* results = serd_model_new(world->world, SERD_INDEX_SPO);
+  SerdRange* r = serd_model_range(model, subject, predicate, object, graph);
+  for (; !serd_range_empty(r); serd_range_next(r)) {
+    serd_model_insert(results, serd_range_front(r));
   }
-  sord_iter_free(i);
+  serd_range_free(r);
   return results;
 }
 
 LilvNodes*
 lilv_world_find_nodes_internal(LilvWorld*      world,
-                               const SordNode* subject,
-                               const SordNode* predicate,
-                               const SordNode* object)
+                               const SerdNode* subject,
+                               const SerdNode* predicate,
+                               const SerdNode* object)
 {
-  return lilv_nodes_from_stream_objects(
+  return lilv_nodes_from_range(
     world,
-    lilv_world_query_internal(world, subject, predicate, object),
-    (object == NULL) ? SORD_OBJECT : SORD_SUBJECT);
-}
-
-static SerdNode
-lilv_new_uri_relative_to_base(const uint8_t* uri_str,
-                              const uint8_t* base_uri_str)
-{
-  SerdURI base_uri;
-  serd_uri_parse(base_uri_str, &base_uri);
-  return serd_node_new_uri_from_string(uri_str, &base_uri, NULL);
+    serd_model_range(world->model, subject, predicate, object, NULL),
+    (object == NULL) ? SERD_OBJECT : SERD_SUBJECT);
 }
 
-const uint8_t*
+const char*
 lilv_world_blank_node_prefix(LilvWorld* world)
 {
   static char str[32];
   snprintf(str, sizeof(str), "%u", world->n_read_files++);
-  return (const uint8_t*)str;
+  return str;
 }
 
 /** Comparator for sequences (e.g. world->plugins). */
@@ -411,24 +344,21 @@ lilv_collection_get_by_uri(const ZixTree* seq, const LilvNode* uri)
 
 static void
 lilv_world_add_spec(LilvWorld*      world,
-                    const SordNode* specification_node,
-                    const SordNode* bundle_node)
+                    const SerdNode* specification_node,
+                    const SerdNode* bundle_node)
 {
   LilvSpec* spec  = (LilvSpec*)malloc(sizeof(LilvSpec));
-  spec->spec      = sord_node_copy(specification_node);
-  spec->bundle    = sord_node_copy(bundle_node);
+  spec->spec      = serd_node_copy(specification_node);
+  spec->bundle    = serd_node_copy(bundle_node);
   spec->data_uris = lilv_nodes_new();
 
   // Add all data files (rdfs:seeAlso)
-  SordIter* files = sord_search(
-    world->model, specification_node, world->uris.rdfs_seeAlso, NULL, NULL);
-  FOREACH_MATCH (files) {
-    const SordNode* file_node = sord_iter_get_node(files, SORD_OBJECT);
-    zix_tree_insert((ZixTree*)spec->data_uris,
-                    lilv_node_new_from_node(world, file_node),
-                    NULL);
+  FOREACH_PAT(
+    s, world->model, specification_node, world->uris.rdfs_seeAlso, NULL, NULL)
+  {
+    const SerdNode* file_node = serd_statement_object(s);
+    zix_tree_insert((ZixTree*)spec->data_uris, serd_node_copy(file_node), NULL);
   }
-  sord_iter_free(files);
 
   // Add specification to world specification list
   spec->next   = world->specs;
@@ -437,15 +367,12 @@ lilv_world_add_spec(LilvWorld*      world,
 
 static void
 lilv_world_add_plugin(LilvWorld*      world,
-                      const SordNode* plugin_node,
+                      const SerdNode* plugin_uri,
                       const LilvNode* manifest_uri,
                       void*           dynmanifest,
-                      const SordNode* bundle)
+                      const SerdNode* bundle)
 {
-  (void)dynmanifest;
-
-  LilvNode*    plugin_uri = lilv_node_new_from_node(world, plugin_node);
-  ZixTreeIter* z          = NULL;
+  ZixTreeIter* z = NULL;
   LilvPlugin*  plugin =
     (LilvPlugin*)lilv_plugins_get_by_uri(world->plugins, plugin_uri);
 
@@ -454,15 +381,13 @@ lilv_world_add_plugin(LilvWorld*      world,
     // (use the first plugin found in LV2_PATH)
     const LilvNode* last_bundle    = lilv_plugin_get_bundle_uri(plugin);
     const char*     plugin_uri_str = lilv_node_as_uri(plugin_uri);
-    if (sord_node_equals(bundle, last_bundle->node)) {
+    if (serd_node_equals(bundle, last_bundle)) {
       LILV_WARNF("Reloading plugin <%s>\n", plugin_uri_str);
       plugin->loaded = false;
-      lilv_node_free(plugin_uri);
     } else {
       LILV_WARNF("Duplicate plugin <%s>\n", plugin_uri_str);
       LILV_WARNF("... found in %s\n", lilv_node_as_string(last_bundle));
-      LILV_WARNF("... and      %s (ignored)\n", sord_node_get_string(bundle));
-      lilv_node_free(plugin_uri);
+      LILV_WARNF("... and      %s (ignored)\n", serd_node_string(bundle));
       return;
     }
   } else if ((z = lilv_collection_find_by_uri((const ZixTree*)world->zombies,
@@ -471,12 +396,10 @@ lilv_world_add_plugin(LilvWorld*      world,
     plugin = (LilvPlugin*)zix_tree_get(z);
     zix_tree_remove((ZixTree*)world->zombies, z);
     zix_tree_insert((ZixTree*)world->plugins, plugin, NULL);
-    lilv_node_free(plugin_uri);
-    lilv_plugin_clear(plugin, lilv_node_new_from_node(world, bundle));
+    lilv_plugin_clear(plugin, bundle);
   } else {
     // Add new plugin to the world
-    plugin = lilv_plugin_new(
-      world, plugin_uri, lilv_node_new_from_node(world, bundle));
+    plugin = lilv_plugin_new(world, plugin_uri, bundle);
 
     // Add manifest as plugin data file (as if it were rdfs:seeAlso)
     zix_tree_insert(
@@ -492,37 +415,40 @@ lilv_world_add_plugin(LilvWorld*      world,
     plugin->dynmanifest = (LilvDynManifest*)dynmanifest;
     ++((LilvDynManifest*)dynmanifest)->refs;
   }
+#else
+  (void)dynmanifest;
 #endif
 
   // Add all plugin data files (rdfs:seeAlso)
-  SordIter* files = sord_search(
-    world->model, plugin_node, world->uris.rdfs_seeAlso, NULL, NULL);
-  FOREACH_MATCH (files) {
-    const SordNode* file_node = sord_iter_get_node(files, SORD_OBJECT);
-    zix_tree_insert((ZixTree*)plugin->data_uris,
-                    lilv_node_new_from_node(world, file_node),
-                    NULL);
+  FOREACH_PAT(s, world->model, plugin_uri, world->uris.rdfs_seeAlso, NULL, NULL)
+  {
+    const SerdNode* file_node = serd_statement_object(s);
+    zix_tree_insert(
+      (ZixTree*)plugin->data_uris, serd_node_copy(file_node), NULL);
   }
-  sord_iter_free(files);
 }
 
 SerdStatus
-lilv_world_load_graph(LilvWorld* world, SordNode* graph, const LilvNode* uri)
+lilv_world_load_graph(LilvWorld*      world,
+                      const SerdNode* graph,
+                      const LilvNode* uri)
 {
-  const SerdNode* base = sord_node_to_serd_node(uri->node);
-  SerdEnv*        env  = serd_env_new(base);
-  SerdReader* reader   = sord_new_reader(world->model, env, SERD_TURTLE, graph);
+  SerdEnv*    env      = serd_env_new(serd_node_string_view(uri));
+  SerdSink*   inserter = serd_inserter_new(world->model, graph);
+  SerdReader* reader   = serd_reader_new(
+    world->world, SERD_TURTLE, 0, env, inserter, LILV_READER_STACK_SIZE);
 
   const SerdStatus st = lilv_world_load_file(world, reader, uri);
 
-  serd_env_free(env);
   serd_reader_free(reader);
+  serd_sink_free(inserter);
+  serd_env_free(env);
   return st;
 }
 
 static void
 lilv_world_load_dyn_manifest(LilvWorld*      world,
-                             SordNode*       bundle_node,
+                             const SerdNode* bundle_node,
                              const LilvNode* manifest)
 {
 #ifdef LILV_DYN_MANIFEST
@@ -533,33 +459,33 @@ lilv_world_load_dyn_manifest(LilvWorld*      world,
   LV2_Dyn_Manifest_Handle handle = NULL;
 
   // ?dman a dynman:DynManifest bundle_node
-  SordModel* model = lilv_world_filter_model(world,
+  SerdModel* model = lilv_world_filter_model(world,
                                              world->model,
                                              NULL,
                                              world->uris.rdf_a,
                                              world->uris.dman_DynManifest,
                                              bundle_node);
-  SordIter*  iter  = sord_begin(model);
-  for (; !sord_iter_end(iter); sord_iter_next(iter)) {
-    const SordNode* dmanifest = sord_iter_get_node(iter, SORD_SUBJECT);
+  SerdIter*  iter  = serd_begin(model);
+  for (; !serd_iter_end(iter); serd_iter_next(iter)) {
+    const SerdNode* dmanifest = serd_iter_get_node(iter, SERD_SUBJECT);
 
     // ?dman lv2:binary ?binary
-    SordIter* binaries = sord_search(
+    SerdIter* binaries = serd_model_find(
       world->model, dmanifest, world->uris.lv2_binary, NULL, bundle_node);
-    if (sord_iter_end(binaries)) {
-      sord_iter_free(binaries);
+    if (serd_iter_end(binaries)) {
+      serd_iter_free(binaries);
       LILV_ERRORF("Dynamic manifest in <%s> has no binaries, ignored\n",
-                  sord_node_get_string(bundle_node));
+                  serd_node_string(bundle_node));
       continue;
     }
 
     // Get binary path
-    const SordNode* binary   = sord_iter_get_node(binaries, SORD_OBJECT);
-    const uint8_t*  lib_uri  = sord_node_get_string(binary);
-    char*           lib_path = lilv_file_uri_parse((const char*)lib_uri, 0);
+    const SerdNode* const binary   = serd_iter_get_node(binaries, SERD_OBJECT);
+    const char* const     lib_uri  = serd_node_string(binary);
+    char* const           lib_path = serd_file_uri_parse(lib_uri, 0);
     if (!lib_path) {
       LILV_ERROR("No dynamic manifest library path\n");
-      sord_iter_free(binaries);
+      serd_iter_free(binaries);
       continue;
     }
 
@@ -569,7 +495,7 @@ lilv_world_load_dyn_manifest(LilvWorld*      world,
     if (!lib) {
       LILV_ERRORF(
         "Failed to open dynmanifest library `%s' (%s)\n", lib_path, dlerror());
-      sord_iter_free(binaries);
+      serd_iter_free(binaries);
       lilv_free(lib_path);
       continue;
     }
@@ -580,7 +506,7 @@ lilv_world_load_dyn_manifest(LilvWorld*      world,
     OpenFunc dmopen = (OpenFunc)lilv_dlfunc(lib, "lv2_dyn_manifest_open");
     if (!dmopen || dmopen(&handle, &dman_features)) {
       LILV_ERRORF("No `lv2_dyn_manifest_open' in `%s'\n", lib_path);
-      sord_iter_free(binaries);
+      serd_iter_free(binaries);
       dlclose(lib);
       lilv_free(lib_path);
       continue;
@@ -592,19 +518,19 @@ lilv_world_load_dyn_manifest(LilvWorld*      world,
       (GetSubjectsFunc)lilv_dlfunc(lib, "lv2_dyn_manifest_get_subjects");
     if (!get_subjects_func) {
       LILV_ERRORF("No `lv2_dyn_manifest_get_subjects' in `%s'\n", lib_path);
-      sord_iter_free(binaries);
+      serd_iter_free(binaries);
       dlclose(lib);
       lilv_free(lib_path);
       continue;
     }
 
     LilvDynManifest* desc = (LilvDynManifest*)malloc(sizeof(LilvDynManifest));
-    desc->bundle          = lilv_node_new_from_node(world, bundle_node);
+    desc->bundle          = serd_node_copy(bundle_node);
     desc->lib             = lib;
     desc->handle          = handle;
     desc->refs            = 0;
 
-    sord_iter_free(binaries);
+    serd_iter_free(binaries);
 
     // Generate data file
     FILE* fd = tmpfile();
@@ -613,12 +539,12 @@ lilv_world_load_dyn_manifest(LilvWorld*      world,
 
     // Parse generated data file into temporary model
     // FIXME
-    const SerdNode* base   = sord_node_to_serd_node(dmanifest);
+    const SerdNode* base   = dmanifest;
     SerdEnv*        env    = serd_env_new(base);
-    SerdReader*     reader = sord_new_reader(
-      world->model, env, SERD_TURTLE, sord_node_copy(dmanifest));
+    SerdReader*     reader = serd_model_new_reader(
+      world->model, env, SERD_TURTLE, serd_node_copy(dmanifest));
     serd_reader_add_blank_prefix(reader, lilv_world_blank_node_prefix(world));
-    serd_reader_read_file_handle(reader, fd, (const uint8_t*)"(dyn-manifest)");
+    serd_reader_read_file_handle(reader, fd, "(dyn-manifest)");
     serd_reader_free(reader);
     serd_env_free(env);
 
@@ -626,32 +552,32 @@ lilv_world_load_dyn_manifest(LilvWorld*      world,
     fclose(fd);
 
     // ?plugin a lv2:Plugin
-    SordModel* plugins = lilv_world_filter_model(world,
+    SerdModel* plugins = lilv_world_filter_model(world,
                                                  world->model,
                                                  NULL,
                                                  world->uris.rdf_a,
                                                  world->uris.lv2_Plugin,
                                                  dmanifest);
-    SordIter*  p       = sord_begin(plugins);
-    FOREACH_MATCH (p) {
-      const SordNode* plug = sord_iter_get_node(p, SORD_SUBJECT);
+    SerdIter*  p       = serd_begin(plugins);
+    FOREACH_MATCH (s, p) {
+      const SerdNode* plug = serd_statement_subject(s);
       lilv_world_add_plugin(world, plug, manifest, desc, bundle_node);
     }
     if (desc->refs == 0) {
-      lilv_dynmanifest_free(desc);
+      free(desc);
     }
-    sord_iter_free(p);
-    sord_free(plugins);
+    serd_iter_free(p);
+    serd_free(plugins);
     lilv_free(lib_path);
   }
-  sord_iter_free(iter);
-  sord_free(model);
+  serd_iter_free(iter);
+  serd_free(model);
 
-#else // LILV_DYN_MANIFEST
+#else
   (void)world;
   (void)bundle_node;
   (void)manifest;
-#endif
+#endif // LILV_DYN_MANIFEST
 }
 
 #ifdef LILV_DYN_MANIFEST
@@ -672,67 +598,88 @@ lilv_dynmanifest_free(LilvDynManifest* dynmanifest)
 #endif // LILV_DYN_MANIFEST
 
 LilvNode*
-lilv_world_get_manifest_uri(LilvWorld* world, const LilvNode* bundle_uri)
+lilv_world_get_manifest_node(LilvWorld* world, const LilvNode* bundle_node)
 {
-  SerdNode manifest_uri = lilv_new_uri_relative_to_base(
-    (const uint8_t*)"manifest.ttl", sord_node_get_string(bundle_uri->node));
-  LilvNode* manifest = lilv_new_uri(world, (const char*)manifest_uri.buf);
-  serd_node_free(&manifest_uri);
-  return manifest;
+  (void)world;
+
+  const SerdURIView bundle_uri   = serd_node_uri_view(bundle_node);
+  const SerdURIView manifest_ref = serd_parse_uri("manifest.ttl");
+  const SerdURIView manifest_uri = serd_resolve_uri(manifest_ref, bundle_uri);
+
+  return serd_new_parsed_uri(manifest_uri);
+}
+
+char*
+lilv_world_get_manifest_path(LilvWorld* world, const LilvNode* bundle_node)
+{
+  const SerdNode* const node = lilv_world_get_manifest_node(world, bundle_node);
+
+  return serd_parse_file_uri(serd_node_string(node), NULL);
 }
 
-static SordModel*
+static SerdModel*
 load_plugin_model(LilvWorld*      world,
                   const LilvNode* bundle_uri,
                   const LilvNode* plugin_uri)
 {
   // Create model and reader for loading into it
-  SordNode*   bundle_node = bundle_uri->node;
-  SordModel*  model       = sord_new(world->world, SORD_SPO | SORD_OPS, false);
-  SerdEnv*    env         = serd_env_new(sord_node_to_serd_node(bundle_node));
-  SerdReader* reader      = sord_new_reader(model, env, SERD_TURTLE, NULL);
+  SerdModel* model =
+    serd_model_new(world->world, SERD_INDEX_SPO | SERD_INDEX_OPS);
+  SerdEnv*    env      = serd_env_new(serd_node_string_view(bundle_uri));
+  SerdSink*   inserter = serd_inserter_new(model, NULL);
+  SerdReader* reader   = serd_reader_new(
+    world->world, SERD_TURTLE, 0, env, inserter, LILV_READER_STACK_SIZE);
 
   // Load manifest
-  LilvNode* manifest_uri = lilv_world_get_manifest_uri(world, bundle_uri);
+  char* manifest_path = lilv_world_get_manifest_path(world, bundle_uri);
+  SerdByteSource* manifest_source =
+    serd_byte_source_new_filename(manifest_path, 4096);
   serd_reader_add_blank_prefix(reader, lilv_world_blank_node_prefix(world));
-  serd_reader_read_file(reader,
-                        (const uint8_t*)lilv_node_as_string(manifest_uri));
+  serd_reader_start(reader, manifest_source);
+  serd_reader_read_document(reader);
+  serd_reader_finish(reader);
 
   // Load any seeAlso files
-  SordModel* files = lilv_world_filter_model(
-    world, model, plugin_uri->node, world->uris.rdfs_seeAlso, NULL, NULL);
-
-  SordIter* f = sord_begin(files);
-  FOREACH_MATCH (f) {
-    const SordNode* file     = sord_iter_get_node(f, SORD_OBJECT);
-    const uint8_t*  file_str = sord_node_get_string(file);
-    if (sord_node_get_type(file) == SORD_URI) {
+  SerdModel* files = lilv_world_filter_model(
+    world, model, plugin_uri, world->uris.rdfs_seeAlso, NULL, NULL);
+
+  SerdIter* f = serd_model_begin(files);
+  for (; !serd_iter_equals(f, serd_model_end(files)); serd_iter_next(f)) {
+    const SerdNode* file    = serd_statement_object(serd_iter_get(f));
+    const char*     uri_str = serd_node_string(file);
+    if (serd_node_type(file) == SERD_URI) {
+      char*           path_str = serd_parse_file_uri(uri_str, NULL);
+      SerdByteSource* source   = serd_byte_source_new_filename(path_str, 4096);
+
       serd_reader_add_blank_prefix(reader, lilv_world_blank_node_prefix(world));
-      serd_reader_read_file(reader, file_str);
+      serd_reader_start(reader, source);
+      serd_reader_read_document(reader);
+      serd_reader_finish(reader);
+
+      serd_byte_source_free(source);
     }
   }
 
-  sord_iter_free(f);
-  sord_free(files);
+  serd_iter_free(f);
+  serd_model_free(files);
   serd_reader_free(reader);
   serd_env_free(env);
-  lilv_node_free(manifest_uri);
 
   return model;
 }
 
 static LilvVersion
-get_version(LilvWorld* world, SordModel* model, const LilvNode* subject)
+get_version(LilvWorld* world, SerdModel* model, const LilvNode* subject)
 {
-  const SordNode* minor_node =
-    sord_get(model, subject->node, world->uris.lv2_minorVersion, NULL, NULL);
-  const SordNode* micro_node =
-    sord_get(model, subject->node, world->uris.lv2_microVersion, NULL, NULL);
+  const SerdNode* minor_node =
+    serd_model_get(model, subject, world->uris.lv2_minorVersion, NULL, NULL);
+  const SerdNode* micro_node =
+    serd_model_get(model, subject, world->uris.lv2_microVersion, NULL, NULL);
 
   LilvVersion version = {0, 0};
   if (minor_node && micro_node) {
-    version.minor = atoi((const char*)sord_node_get_string(minor_node));
-    version.micro = atoi((const char*)sord_node_get_string(micro_node));
+    version.minor = atoi(serd_node_string(minor_node));
+    version.micro = atoi(serd_node_string(micro_node));
   }
 
   return version;
@@ -742,16 +689,14 @@ void
 lilv_world_load_bundle(LilvWorld* world, const LilvNode* bundle_uri)
 {
   if (!lilv_node_is_uri(bundle_uri)) {
-    LILV_ERRORF("Bundle URI `%s' is not a URI\n",
-                sord_node_get_string(bundle_uri->node));
+    LILV_ERRORF("Bundle URI `%s' is not a URI\n", serd_node_string(bundle_uri));
     return;
   }
 
-  SordNode* bundle_node = bundle_uri->node;
-  LilvNode* manifest    = lilv_world_get_manifest_uri(world, bundle_uri);
+  LilvNode* manifest = lilv_world_get_manifest_node(world, bundle_uri);
 
-  // Read manifest into model with graph = bundle_node
-  SerdStatus st = lilv_world_load_graph(world, bundle_node, manifest);
+  // Read manifest into model with graph = bundle_uri
+  SerdStatus st = lilv_world_load_graph(world, bundle_uri, manifest);
   if (st > SERD_FAILURE) {
     LILV_ERRORF("Error reading %s\n", lilv_node_as_string(manifest));
     lilv_node_free(manifest);
@@ -759,32 +704,32 @@ lilv_world_load_bundle(LilvWorld* world, const LilvNode* bundle_uri)
   }
 
   // ?plugin a lv2:Plugin
-  SordIter* plug_results = sord_search(
-    world->model, NULL, world->uris.rdf_a, world->uris.lv2_Plugin, bundle_node);
+  SerdRange* plug_results = serd_model_range(
+    world->model, NULL, world->uris.rdf_a, world->uris.lv2_Plugin, bundle_uri);
 
   // Find any loaded plugins that will be replaced with a newer version
   LilvNodes* unload_uris = lilv_nodes_new();
-  FOREACH_MATCH (plug_results) {
-    const SordNode* plug = sord_iter_get_node(plug_results, SORD_SUBJECT);
+  FOREACH_MATCH (s, plug_results) {
+    const SerdNode* plug = serd_statement_subject(s);
 
-    LilvNode*         plugin_uri = lilv_node_new_from_node(world, plug);
+    LilvNode*         plugin_uri = serd_node_copy(plug);
     const LilvPlugin* plugin =
       lilv_plugins_get_by_uri(world->plugins, plugin_uri);
     const LilvNode* last_bundle =
       plugin ? lilv_plugin_get_bundle_uri(plugin) : NULL;
-    if (!plugin || sord_node_equals(bundle_node, last_bundle->node)) {
+    if (!plugin || serd_node_equals(bundle_uri, last_bundle)) {
       // No previously loaded version, or it's from the same bundle
       lilv_node_free(plugin_uri);
       continue;
     }
 
     // Compare versions
-    SordModel*  this_model   = load_plugin_model(world, bundle_uri, plugin_uri);
+    SerdModel*  this_model   = load_plugin_model(world, bundle_uri, plugin_uri);
     LilvVersion this_version = get_version(world, this_model, plugin_uri);
-    SordModel*  last_model = load_plugin_model(world, last_bundle, plugin_uri);
+    SerdModel*  last_model = load_plugin_model(world, last_bundle, plugin_uri);
     LilvVersion last_version = get_version(world, last_model, plugin_uri);
-    sord_free(this_model);
-    sord_free(last_model);
+    serd_model_free(this_model);
+    serd_model_free(last_model);
     const int cmp = lilv_version_cmp(&this_version, &last_version);
     if (cmp > 0) {
       zix_tree_insert(
@@ -792,20 +737,20 @@ lilv_world_load_bundle(LilvWorld* world, const LilvNode* bundle_uri)
       LILV_WARNF("Replacing version %d.%d of <%s> from <%s>\n",
                  last_version.minor,
                  last_version.micro,
-                 sord_node_get_string(plug),
-                 sord_node_get_string(last_bundle->node));
+                 serd_node_string(plug),
+                 serd_node_string(last_bundle));
       LILV_NOTEF("New version %d.%d found in <%s>\n",
                  this_version.minor,
                  this_version.micro,
-                 sord_node_get_string(bundle_node));
+                 serd_node_string(bundle_uri));
     } else if (cmp < 0) {
-      LILV_WARNF("Ignoring bundle <%s>\n", sord_node_get_string(bundle_node));
+      LILV_WARNF("Ignoring bundle <%s>\n", serd_node_string(bundle_uri));
       LILV_NOTEF("Newer version of <%s> loaded from <%s>\n",
-                 sord_node_get_string(plug),
-                 sord_node_get_string(last_bundle->node));
+                 serd_node_string(plug),
+                 serd_node_string(last_bundle));
       lilv_node_free(plugin_uri);
-      sord_iter_free(plug_results);
-      lilv_world_drop_graph(world, bundle_node);
+      serd_range_free(plug_results);
+      lilv_world_drop_graph(world, bundle_uri);
       lilv_node_free(manifest);
       lilv_nodes_free(unload_uris);
       return;
@@ -813,7 +758,7 @@ lilv_world_load_bundle(LilvWorld* world, const LilvNode* bundle_uri)
     lilv_node_free(plugin_uri);
   }
 
-  sord_iter_free(plug_results);
+  serd_range_free(plug_results);
 
   // Unload any old conflicting plugins
   LilvNodes* unload_bundles = lilv_nodes_new();
@@ -837,49 +782,46 @@ lilv_world_load_bundle(LilvWorld* world, const LilvNode* bundle_uri)
   lilv_nodes_free(unload_bundles);
 
   // Re-search for plugin results now that old plugins are gone
-  plug_results = sord_search(
-    world->model, NULL, world->uris.rdf_a, world->uris.lv2_Plugin, bundle_node);
+  plug_results = serd_model_range(
+    world->model, NULL, world->uris.rdf_a, world->uris.lv2_Plugin, bundle_uri);
 
-  FOREACH_MATCH (plug_results) {
-    const SordNode* plug = sord_iter_get_node(plug_results, SORD_SUBJECT);
-    lilv_world_add_plugin(world, plug, manifest, NULL, bundle_node);
+  FOREACH_MATCH (s, plug_results) {
+    const SerdNode* plug = serd_statement_subject(s);
+    lilv_world_add_plugin(world, plug, manifest, NULL, bundle_uri);
   }
-  sord_iter_free(plug_results);
+  serd_range_free(plug_results);
 
-  lilv_world_load_dyn_manifest(world, bundle_node, manifest);
+  lilv_world_load_dyn_manifest(world, bundle_uri, manifest);
 
   // ?spec a lv2:Specification
   // ?spec a owl:Ontology
-  const SordNode* spec_preds[] = {
+  const SerdNode* spec_preds[] = {
     world->uris.lv2_Specification, world->uris.owl_Ontology, NULL};
-  for (const SordNode** p = spec_preds; *p; ++p) {
-    SordIter* i =
-      sord_search(world->model, NULL, world->uris.rdf_a, *p, bundle_node);
-    FOREACH_MATCH (i) {
-      const SordNode* spec = sord_iter_get_node(i, SORD_SUBJECT);
-      lilv_world_add_spec(world, spec, bundle_node);
+  for (const SerdNode** p = spec_preds; *p; ++p) {
+    FOREACH_PAT(s, world->model, NULL, world->uris.rdf_a, *p, bundle_uri)
+    {
+      const SerdNode* spec = serd_statement_subject(s);
+      lilv_world_add_spec(world, spec, bundle_uri);
     }
-    sord_iter_free(i);
   }
 
   lilv_node_free(manifest);
 }
 
 static int
-lilv_world_drop_graph(LilvWorld* world, const SordNode* graph)
+lilv_world_drop_graph(LilvWorld* world, const SerdNode* graph)
 {
-  SordIter* i = sord_search(world->model, NULL, NULL, NULL, graph);
-  while (!sord_iter_end(i)) {
-    const SerdStatus st = sord_erase(world->model, i);
-    if (st) {
-      LILV_ERRORF("Error removing statement from <%s> (%s)\n",
-                  sord_node_get_string(graph),
-                  serd_strerror(st));
-      return st;
-    }
+  SerdRange*       r  = serd_model_range(world->model, NULL, NULL, NULL, graph);
+  const SerdStatus st = serd_model_erase_range(world->model, r);
+
+  if (st) {
+    LILV_ERRORF("Error dropping graph <%s> (%s)\n",
+                serd_node_string(graph),
+                serd_strerror(st));
+    return st;
   }
-  sord_iter_free(i);
 
+  serd_range_free(r);
   return 0;
 }
 
@@ -941,20 +883,25 @@ lilv_world_unload_bundle(LilvWorld* world, const LilvNode* bundle_uri)
   }
 
   // Drop everything in bundle graph
-  return lilv_world_drop_graph(world, bundle_uri->node);
+  return lilv_world_drop_graph(world, bundle_uri);
 }
 
 static void
 load_dir_entry(const char* dir, const char* name, void* data)
 {
   LilvWorld* world = (LilvWorld*)data;
-  char*      path  = lilv_strjoin(dir, "/", name, "/", NULL);
-  SerdNode   suri  = serd_node_new_file_uri((const uint8_t*)path, 0, 0, true);
-  LilvNode*  node  = lilv_new_uri(world, (const char*)suri.buf);
+  if (!strcmp(name, ".") || !strcmp(name, "..")) {
+    return;
+  }
+
+  char*     path = lilv_strjoin(dir, "/", name, "/", NULL);
+  SerdNode* suri =
+    serd_new_file_uri(SERD_MEASURE_STRING(path), SERD_EMPTY_STRING());
+  LilvNode* node = lilv_new_uri(world, serd_node_string(suri));
 
   lilv_world_load_bundle(world, node);
   lilv_node_free(node);
-  serd_node_free(&suri);
+  serd_node_free(suri);
   free(path);
 }
 
@@ -1025,34 +972,29 @@ lilv_world_load_plugin_classes(LilvWorld* world)
      is e.g. how a host would build a menu), they won't be seen anyway...
   */
 
-  SordIter* classes = sord_search(
-    world->model, NULL, world->uris.rdf_a, world->uris.rdfs_Class, NULL);
-  FOREACH_MATCH (classes) {
-    const SordNode* class_node = sord_iter_get_node(classes, SORD_SUBJECT);
+  FOREACH_PAT(
+    s, world->model, NULL, world->uris.rdf_a, world->uris.rdfs_Class, NULL)
+  {
+    const SerdNode* class_node = serd_statement_subject(s);
 
-    SordNode* parent = sord_get(
+    const SerdNode* parent = serd_model_get(
       world->model, class_node, world->uris.rdfs_subClassOf, NULL, NULL);
-    if (!parent || sord_node_get_type(parent) != SORD_URI) {
+    if (!parent || serd_node_type(parent) != SERD_URI) {
       continue;
     }
 
-    SordNode* label =
-      sord_get(world->model, class_node, world->uris.rdfs_label, NULL, NULL);
+    const SerdNode* label = serd_model_get(
+      world->model, class_node, world->uris.rdfs_label, NULL, NULL);
     if (!label) {
-      sord_node_free(world->world, parent);
       continue;
     }
 
-    LilvPluginClass* pclass = lilv_plugin_class_new(
-      world, parent, class_node, (const char*)sord_node_get_string(label));
+    LilvPluginClass* pclass =
+      lilv_plugin_class_new(world, parent, class_node, serd_node_string(label));
     if (pclass) {
       zix_tree_insert((ZixTree*)world->plugin_classes, pclass, NULL);
     }
-
-    sord_node_free(world->world, label);
-    sord_node_free(world->world, parent);
   }
-  sord_iter_free(classes);
 }
 
 void
@@ -1074,11 +1016,11 @@ lilv_world_load_all(LilvWorld* world)
       (const LilvPlugin*)lilv_collection_get((ZixTree*)world->plugins, p);
 
     // ?new dc:replaces plugin
-    if (sord_ask(world->model,
-                 NULL,
-                 world->uris.dc_replaces,
-                 lilv_plugin_get_uri(plugin)->node,
-                 NULL)) {
+    if (serd_model_ask(world->model,
+                       NULL,
+                       world->uris.dc_replaces,
+                       lilv_plugin_get_uri(plugin),
+                       NULL)) {
       // TODO: Check if replacement is a known plugin? (expensive)
       ((LilvPlugin*)plugin)->replaced = true;
     }
@@ -1092,25 +1034,33 @@ lilv_world_load_all(LilvWorld* world)
 SerdStatus
 lilv_world_load_file(LilvWorld* world, SerdReader* reader, const LilvNode* uri)
 {
-  ZixTreeIter* iter = NULL;
+  ZixTreeIter* iter;
   if (!zix_tree_find((ZixTree*)world->loaded_files, uri, &iter)) {
     return SERD_FAILURE; // File has already been loaded
   }
 
-  size_t               uri_len = 0;
-  const uint8_t* const uri_str =
-    sord_node_get_string_counted(uri->node, &uri_len);
-  if (strncmp((const char*)uri_str, "file:", 5)) {
+  const char* const uri_str = serd_node_string(uri);
+  const size_t      uri_len = serd_node_length(uri);
+  if (strncmp(uri_str, "file:", 5)) {
     return SERD_FAILURE; // Not a local file
+  } else if (strcmp(uri_str + uri_len - 4, ".ttl")) {
+    return SERD_FAILURE; // Not a Turtle file
   }
 
-  if (strcmp((const char*)uri_str + uri_len - 4, ".ttl")) {
-    return SERD_FAILURE; // Not a Turtle file
+  SerdStatus st       = SERD_SUCCESS;
+  char*      hostname = NULL;
+  char*      filename = serd_parse_file_uri(serd_node_string(uri), &hostname);
+  if (!filename || hostname) {
+    return SERD_ERR_BAD_ARG;
   }
 
+  SerdByteSource* const source =
+    serd_byte_source_new_filename(filename, PAGE_SIZE);
+
   serd_reader_add_blank_prefix(reader, lilv_world_blank_node_prefix(world));
-  const SerdStatus st = serd_reader_read_file(reader, uri_str);
-  if (st) {
+  if ((st = serd_reader_start(reader, source)) ||
+      (st = serd_reader_read_document(reader)) ||
+      (st = serd_reader_finish(reader))) {
     LILV_ERRORF("Error loading file `%s'\n", lilv_node_as_string(uri));
     return st;
   }
@@ -1124,30 +1074,29 @@ int
 lilv_world_load_resource(LilvWorld* world, const LilvNode* resource)
 {
   if (!lilv_node_is_uri(resource) && !lilv_node_is_blank(resource)) {
-    LILV_ERRORF("Node `%s' is not a resource\n",
-                sord_node_get_string(resource->node));
+    LILV_ERRORF("Node `%s' is not a resource\n", serd_node_string(resource));
     return -1;
   }
 
-  SordModel* files = lilv_world_filter_model(
-    world, world->model, resource->node, world->uris.rdfs_seeAlso, NULL, NULL);
+  SerdModel* files = lilv_world_filter_model(
+    world, world->model, resource, world->uris.rdfs_seeAlso, NULL, NULL);
 
-  SordIter* f      = sord_begin(files);
+  SerdIter* f      = serd_model_begin(files);
   int       n_read = 0;
-  FOREACH_MATCH (f) {
-    const SordNode* file      = sord_iter_get_node(f, SORD_OBJECT);
-    const uint8_t*  file_str  = sord_node_get_string(file);
-    LilvNode*       file_node = lilv_node_new_from_node(world, file);
-    if (sord_node_get_type(file) != SORD_URI) {
+  for (; !serd_iter_equals(f, serd_model_end(files)); serd_iter_next(f)) {
+    const SerdNode* file      = serd_statement_object(serd_iter_get(f));
+    const char*     file_str  = serd_node_string(file);
+    LilvNode*       file_node = serd_node_copy(file);
+    if (serd_node_type(file) != SERD_URI) {
       LILV_ERRORF("rdfs:seeAlso node `%s' is not a URI\n", file_str);
-    } else if (!lilv_world_load_graph(world, (SordNode*)file, file_node)) {
+    } else if (!lilv_world_load_graph(world, (SerdNode*)file, file_node)) {
       ++n_read;
     }
     lilv_node_free(file_node);
   }
-  sord_iter_free(f);
+  serd_iter_free(f);
 
-  sord_free(files);
+  serd_model_free(files);
   return n_read;
 }
 
@@ -1155,31 +1104,30 @@ int
 lilv_world_unload_resource(LilvWorld* world, const LilvNode* resource)
 {
   if (!lilv_node_is_uri(resource) && !lilv_node_is_blank(resource)) {
-    LILV_ERRORF("Node `%s' is not a resource\n",
-                sord_node_get_string(resource->node));
+    LILV_ERRORF("Node `%s' is not a resource\n", serd_node_string(resource));
     return -1;
   }
 
-  SordModel* files = lilv_world_filter_model(
-    world, world->model, resource->node, world->uris.rdfs_seeAlso, NULL, NULL);
+  SerdModel* files = lilv_world_filter_model(
+    world, world->model, resource, world->uris.rdfs_seeAlso, NULL, NULL);
 
-  SordIter* f         = sord_begin(files);
+  SerdIter* f         = serd_model_begin(files);
   int       n_dropped = 0;
-  FOREACH_MATCH (f) {
-    const SordNode* file      = sord_iter_get_node(f, SORD_OBJECT);
-    LilvNode*       file_node = lilv_node_new_from_node(world, file);
-    if (sord_node_get_type(file) != SORD_URI) {
+  for (; !serd_iter_equals(f, serd_model_end(files)); serd_iter_next(f)) {
+    const SerdNode* file      = serd_statement_object(serd_iter_get(f));
+    LilvNode*       file_node = serd_node_copy(file);
+    if (serd_node_type(file) != SERD_URI) {
       LILV_ERRORF("rdfs:seeAlso node `%s' is not a URI\n",
-                  sord_node_get_string(file));
-    } else if (!lilv_world_drop_graph(world, file_node->node)) {
+                  serd_node_string(file));
+    } else if (!lilv_world_drop_graph(world, file_node)) {
       lilv_world_unload_file(world, file_node);
       ++n_dropped;
     }
     lilv_node_free(file_node);
   }
-  sord_iter_free(f);
+  serd_iter_free(f);
 
-  sord_free(files);
+  serd_model_free(files);
   return n_dropped;
 }
 
@@ -1205,13 +1153,11 @@ LilvNode*
 lilv_world_get_symbol(LilvWorld* world, const LilvNode* subject)
 {
   // Check for explicitly given symbol
-  SordNode* snode =
-    sord_get(world->model, subject->node, world->uris.lv2_symbol, NULL, NULL);
+  const SerdNode* snode =
+    serd_model_get(world->model, subject, world->uris.lv2_symbol, NULL, NULL);
 
   if (snode) {
-    LilvNode* ret = lilv_node_new_from_node(world, snode);
-    sord_node_free(world->world, snode);
-    return ret;
+    return serd_node_copy(snode);
   }
 
   if (!lilv_node_is_uri(subject)) {
@@ -1219,16 +1165,15 @@ lilv_world_get_symbol(LilvWorld* world, const LilvNode* subject)
   }
 
   // Find rightmost segment of URI
-  SerdURI uri;
-  serd_uri_parse((const uint8_t*)lilv_node_as_uri(subject), &uri);
+  SerdURIView uri = serd_parse_uri(lilv_node_as_uri(subject));
   const char* str = "_";
   if (uri.fragment.buf) {
-    str = (const char*)uri.fragment.buf + 1;
+    str = uri.fragment.buf + 1;
   } else if (uri.query.buf) {
-    str = (const char*)uri.query.buf;
+    str = uri.query.buf;
   } else if (uri.path.buf) {
-    const char* last_slash = strrchr((const char*)uri.path.buf, '/');
-    str = last_slash ? (last_slash + 1) : (const char*)uri.path.buf;
+    const char* last_slash = strrchr(uri.path.buf, '/');
+    str                    = last_slash ? (last_slash + 1) : uri.path.buf;
   }
 
   // Replace invalid characters