WIP: Port to serd1

1 files changed, 243 insertions, 293 deletions

diff --git a/src/plugin.c b/src/plugin.c
index 9c7cbfd..1b34e44 100644
--- a/src/plugin.c
+++ b/src/plugin.c
@@ -18,7 +18,6 @@
 
 #include "lilv/lilv.h"
 #include "serd/serd.h"
-#include "sord/sord.h"
 #include "zix/tree.h"
 
 #include "lv2/core/lv2.h"
@@ -36,13 +35,18 @@
 #include <stdlib.h>
 #include <string.h>
 
-#define NS_DOAP (const uint8_t*)"http://usefulinc.com/ns/doap#"
-#define NS_FOAF (const uint8_t*)"http://xmlns.com/foaf/0.1/"
+#define NS_DOAP "http://usefulinc.com/ns/doap#"
+#define NS_FOAF "http://xmlns.com/foaf/0.1/"
+#define NS_LV2 "http://lv2plug.in/ns/lv2core#"
+#define NS_OWL "http://www.w3.org/2002/07/owl#"
+#define NS_RDF "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+#define NS_RDFS "http://www.w3.org/2000/01/rdf-schema#"
+#define NS_XSD "http://www.w3.org/2001/XMLSchema#"
 
 static void
-lilv_plugin_init(LilvPlugin* plugin, LilvNode* bundle_uri)
+lilv_plugin_init(LilvPlugin* plugin, const LilvNode* bundle_uri)
 {
-  plugin->bundle_uri = bundle_uri;
+  plugin->bundle_uri = lilv_node_duplicate(bundle_uri);
   plugin->binary_uri = NULL;
 #ifdef LILV_DYN_MANIFEST
   plugin->dynmanifest = NULL;
@@ -56,21 +60,22 @@ lilv_plugin_init(LilvPlugin* plugin, LilvNode* bundle_uri)
   plugin->replaced     = false;
 }
 
-/** Ownership of `uri` and `bundle` is taken */
 LilvPlugin*
-lilv_plugin_new(LilvWorld* world, LilvNode* uri, LilvNode* bundle_uri)
+lilv_plugin_new(LilvWorld*      world,
+                const LilvNode* uri,
+                const LilvNode* bundle_uri)
 {
   LilvPlugin* plugin = (LilvPlugin*)malloc(sizeof(LilvPlugin));
 
   plugin->world      = world;
-  plugin->plugin_uri = uri;
+  plugin->plugin_uri = lilv_node_duplicate(uri);
 
   lilv_plugin_init(plugin, bundle_uri);
   return plugin;
 }
 
 void
-lilv_plugin_clear(LilvPlugin* plugin, LilvNode* bundle_uri)
+lilv_plugin_clear(LilvPlugin* plugin, const LilvNode* bundle_uri)
 {
   lilv_node_free(plugin->bundle_uri);
   lilv_node_free(plugin->binary_uri);
@@ -119,37 +124,23 @@ lilv_plugin_free(LilvPlugin* plugin)
 
 static LilvNode*
 lilv_plugin_get_one(const LilvPlugin* plugin,
-                    const SordNode*   subject,
-                    const SordNode*   predicate)
+                    const SerdNode*   subject,
+                    const SerdNode*   predicate)
 {
-  /* TODO: This is slower than it could be in some cases, but it's simpler to
-     use the existing i18n code. */
-
-  SordIter* stream =
-    lilv_world_query_internal(plugin->world, subject, predicate, NULL);
-
-  LilvNodes* nodes =
-    lilv_nodes_from_stream_objects(plugin->world, stream, SORD_OBJECT);
-
-  if (nodes) {
-    LilvNode* value = lilv_node_duplicate(lilv_nodes_get_first(nodes));
-    lilv_nodes_free(nodes);
-    return value;
-  }
-
-  return NULL;
+  return serd_node_copy(
+    serd_model_get(plugin->world->model, subject, predicate, NULL, NULL));
 }
 
 LilvNode*
 lilv_plugin_get_unique(const LilvPlugin* plugin,
-                       const SordNode*   subject,
-                       const SordNode*   predicate)
+                       const SerdNode*   subject,
+                       const SerdNode*   predicate)
 {
   LilvNode* ret = lilv_plugin_get_one(plugin, subject, predicate);
   if (!ret) {
     LILV_ERRORF("No value found for (%s %s ...) property\n",
-                sord_node_get_string(subject),
-                sord_node_get_string(predicate));
+                serd_node_string(subject),
+                serd_node_string(predicate));
   }
   return ret;
 }
@@ -157,56 +148,59 @@ lilv_plugin_get_unique(const LilvPlugin* plugin,
 static void
 lilv_plugin_load(LilvPlugin* plugin)
 {
-  SordNode*       bundle_uri_node  = plugin->bundle_uri->node;
-  const SerdNode* bundle_uri_snode = sord_node_to_serd_node(bundle_uri_node);
+  SerdNode* bundle_uri_node = plugin->bundle_uri;
 
-  SerdEnv*    env = serd_env_new(bundle_uri_snode);
-  SerdReader* reader =
-    sord_new_reader(plugin->world->model, env, SERD_TURTLE, bundle_uri_node);
+  SerdEnv*  env      = serd_env_new(serd_node_string_view(bundle_uri_node));
+  SerdSink* inserter = serd_inserter_new(plugin->world->model, bundle_uri_node);
 
-  SordModel* prots = lilv_world_filter_model(plugin->world,
+  SerdReader* reader = serd_reader_new(plugin->world->world,
+                                       SERD_TURTLE,
+                                       0,
+                                       env,
+                                       inserter,
+                                       LILV_READER_STACK_SIZE);
+
+  SerdModel* prots = lilv_world_filter_model(plugin->world,
                                              plugin->world->model,
-                                             plugin->plugin_uri->node,
+                                             plugin->plugin_uri,
                                              plugin->world->uris.lv2_prototype,
                                              NULL,
                                              NULL);
-  SordModel* skel  = sord_new(plugin->world->world, SORD_SPO, false);
-  SordIter*  iter  = sord_begin(prots);
-  for (; !sord_iter_end(iter); sord_iter_next(iter)) {
-    const SordNode* t         = sord_iter_get_node(iter, SORD_OBJECT);
-    LilvNode*       prototype = lilv_node_new_from_node(plugin->world, t);
+  SerdModel* skel  = serd_model_new(plugin->world->world, SERD_INDEX_SPO);
+  SerdIter*  iter  = serd_model_begin(prots);
+  for (; !serd_iter_equals(iter, serd_model_end(prots)); serd_iter_next(iter)) {
+    const SerdStatement* statement = serd_iter_get(iter);
+    const SerdNode*      t         = serd_statement_object(statement);
+    LilvNode*            prototype = serd_node_copy(t);
 
     lilv_world_load_resource(plugin->world, prototype);
 
-    SordIter* statements =
-      sord_search(plugin->world->model, prototype->node, NULL, NULL, NULL);
-    FOREACH_MATCH (statements) {
-      SordQuad quad;
-      sord_iter_get(statements, quad);
-      quad[0] = plugin->plugin_uri->node;
-      sord_add(skel, quad);
+    FOREACH_PAT(s, plugin->world->model, prototype, NULL, NULL, NULL)
+    {
+      serd_model_add(skel,
+                     plugin->plugin_uri,
+                     serd_statement_predicate(s),
+                     serd_statement_object(s),
+                     NULL);
     }
 
-    sord_iter_free(statements);
     lilv_node_free(prototype);
   }
-  sord_iter_free(iter);
+  serd_iter_free(iter);
 
-  for (iter = sord_begin(skel); !sord_iter_end(iter); sord_iter_next(iter)) {
-    SordQuad quad;
-    sord_iter_get(iter, quad);
-    sord_add(plugin->world->model, quad);
-  }
-  sord_iter_free(iter);
-  sord_free(skel);
-  sord_free(prots);
+  SerdRange* all = serd_model_all(skel, SERD_ORDER_SPO);
+  serd_model_add_range(plugin->world->model, all);
+  serd_range_free(all);
+
+  serd_model_free(skel);
+  serd_model_free(prots);
 
   // Parse all the plugin's data files into RDF model
   SerdStatus st = SERD_SUCCESS;
   LILV_FOREACH (nodes, i, plugin->data_uris) {
     const LilvNode* data_uri = lilv_nodes_get(plugin->data_uris, i);
 
-    serd_env_set_base_uri(env, sord_node_to_serd_node(data_uri->node));
+    serd_env_set_base_uri(env, serd_node_string_view(data_uri));
     st = lilv_world_load_file(plugin->world, reader, data_uri);
     if (st > SERD_FAILURE) {
       break;
@@ -217,6 +211,7 @@ lilv_plugin_load(LilvPlugin* plugin)
     plugin->loaded       = true;
     plugin->parse_errors = true;
     serd_reader_free(reader);
+    serd_sink_free(inserter);
     serd_env_free(env);
     return;
   }
@@ -229,8 +224,8 @@ lilv_plugin_load(LilvPlugin* plugin)
     GetDataFunc get_data_func = (GetDataFunc)lilv_dlfunc(
       plugin->dynmanifest->lib, "lv2_dyn_manifest_get_data");
     if (get_data_func) {
-      const SordNode* bundle = plugin->dynmanifest->bundle->node;
-      serd_env_set_base_uri(env, sord_node_to_serd_node(bundle));
+      const SerdNode* bundle = plugin->dynmanifest->bundle;
+      serd_env_set_base_uri(env, bundle);
       FILE* fd = tmpfile();
       get_data_func(plugin->dynmanifest->handle,
                     fd,
@@ -238,13 +233,13 @@ lilv_plugin_load(LilvPlugin* plugin)
       rewind(fd);
       serd_reader_add_blank_prefix(reader,
                                    lilv_world_blank_node_prefix(plugin->world));
-      serd_reader_read_file_handle(
-        reader, fd, (const uint8_t*)"(dyn-manifest)");
+      serd_reader_read_file_handle(reader, fd, "(dyn-manifest)");
       fclose(fd);
     }
   }
 #endif
   serd_reader_free(reader);
+  serd_sink_free(inserter);
   serd_env_free(env);
 
   plugin->loaded = true;
@@ -273,22 +268,21 @@ lilv_plugin_load_ports_if_necessary(const LilvPlugin* const_plugin)
     plugin->ports    = (LilvPort**)malloc(sizeof(LilvPort*));
     plugin->ports[0] = NULL;
 
-    SordIter* ports = lilv_world_query_internal(plugin->world,
-                                                plugin->plugin_uri->node,
-                                                plugin->world->uris.lv2_port,
-                                                NULL);
-
-    FOREACH_MATCH (ports) {
-      const SordNode* port = sord_iter_get_node(ports, SORD_OBJECT);
+    SerdRange* ports = serd_model_range(plugin->world->model,
+                                        plugin->plugin_uri,
+                                        plugin->world->uris.lv2_port,
+                                        NULL,
+                                        NULL);
 
-      LilvNode* index =
+    FOREACH_MATCH (s, ports) {
+      const SerdNode* port = serd_statement_object(s);
+      LilvNode*       index =
         lilv_plugin_get_unique(plugin, port, plugin->world->uris.lv2_index);
-
       LilvNode* symbol =
         lilv_plugin_get_unique(plugin, port, plugin->world->uris.lv2_symbol);
 
       if (!lilv_node_is_string(symbol) ||
-          !is_symbol((const char*)sord_node_get_string(symbol->node))) {
+          !is_symbol(serd_node_string(symbol))) {
         LILV_ERRORF("Plugin <%s> port symbol `%s' is invalid\n",
                     lilv_node_as_uri(plugin->plugin_uri),
                     lilv_node_as_string(symbol));
@@ -322,30 +316,29 @@ lilv_plugin_load_ports_if_necessary(const LilvPlugin* const_plugin)
 
       // Havn't seen this port yet, add it to array
       if (!this_port) {
-        this_port = lilv_port_new(
-          plugin->world, port, this_index, lilv_node_as_string(symbol));
+        this_port =
+          lilv_port_new(port, this_index, lilv_node_as_string(symbol));
         plugin->ports[this_index] = this_port;
       }
 
-      SordIter* types = lilv_world_query_internal(
-        plugin->world, port, plugin->world->uris.rdf_a, NULL);
-      FOREACH_MATCH (types) {
-        const SordNode* type = sord_iter_get_node(types, SORD_OBJECT);
-        if (sord_node_get_type(type) == SORD_URI) {
-          zix_tree_insert((ZixTree*)this_port->classes,
-                          lilv_node_new_from_node(plugin->world, type),
-                          NULL);
+      SerdRange* types = serd_model_range(
+        plugin->world->model, port, plugin->world->uris.rdf_a, NULL, NULL);
+      FOREACH_MATCH (t, types) {
+        const SerdNode* type = serd_statement_object(t);
+        if (serd_node_type(type) == SERD_URI) {
+          zix_tree_insert(
+            (ZixTree*)this_port->classes, serd_node_copy(type), NULL);
         } else {
           LILV_WARNF("Plugin <%s> port type is not a URI\n",
                      lilv_node_as_uri(plugin->plugin_uri));
         }
       }
-      sord_iter_free(types);
+      serd_range_free(types);
 
       lilv_node_free(symbol);
       lilv_node_free(index);
     }
-    sord_iter_free(ports);
+    serd_range_free(ports);
 
     // Check sanity
     for (uint32_t i = 0; i < plugin->num_ports; ++i) {
@@ -387,19 +380,19 @@ lilv_plugin_get_library_uri(const LilvPlugin* plugin)
   lilv_plugin_load_if_necessary((LilvPlugin*)plugin);
   if (!plugin->binary_uri) {
     // <plugin> lv2:binary ?binary
-    SordIter* i = lilv_world_query_internal(plugin->world,
-                                            plugin->plugin_uri->node,
-                                            plugin->world->uris.lv2_binary,
-                                            NULL);
-    FOREACH_MATCH (i) {
-      const SordNode* binary_node = sord_iter_get_node(i, SORD_OBJECT);
-      if (sord_node_get_type(binary_node) == SORD_URI) {
-        ((LilvPlugin*)plugin)->binary_uri =
-          lilv_node_new_from_node(plugin->world, binary_node);
+    SerdRange* i = serd_model_range(plugin->world->model,
+                                    plugin->plugin_uri,
+                                    plugin->world->uris.lv2_binary,
+                                    NULL,
+                                    NULL);
+    FOREACH_MATCH (s, i) {
+      const SerdNode* binary_node = serd_statement_object(s);
+      if (serd_node_type(binary_node) == SERD_URI) {
+        ((LilvPlugin*)plugin)->binary_uri = serd_node_copy(binary_node);
         break;
       }
     }
-    sord_iter_free(i);
+    serd_range_free(i);
   }
   if (!plugin->binary_uri) {
     LILV_WARNF("Plugin <%s> has no lv2:binary\n",
@@ -420,15 +413,18 @@ lilv_plugin_get_class(const LilvPlugin* plugin)
   lilv_plugin_load_if_necessary((LilvPlugin*)plugin);
   if (!plugin->plugin_class) {
     // <plugin> a ?class
-    SordIter* c = lilv_world_query_internal(
-      plugin->world, plugin->plugin_uri->node, plugin->world->uris.rdf_a, NULL);
-    FOREACH_MATCH (c) {
-      const SordNode* class_node = sord_iter_get_node(c, SORD_OBJECT);
-      if (sord_node_get_type(class_node) != SORD_URI) {
+    SerdRange* c = serd_model_range(plugin->world->model,
+                                    plugin->plugin_uri,
+                                    plugin->world->uris.rdf_a,
+                                    NULL,
+                                    NULL);
+    FOREACH_MATCH (s, c) {
+      const SerdNode* class_node = serd_statement_object(s);
+      if (serd_node_type(class_node) != SERD_URI) {
         continue;
       }
 
-      LilvNode* klass = lilv_node_new_from_node(plugin->world, class_node);
+      LilvNode* klass = serd_node_copy(class_node);
       if (!lilv_node_equals(klass, plugin->world->lv2_plugin_class->uri)) {
         const LilvPluginClass* pclass =
           lilv_plugin_classes_get_by_uri(plugin->world->plugin_classes, klass);
@@ -442,7 +438,7 @@ lilv_plugin_get_class(const LilvPlugin* plugin)
 
       lilv_node_free(klass);
     }
-    sord_iter_free(c);
+    serd_range_free(c);
 
     if (plugin->plugin_class == NULL) {
       ((LilvPlugin*)plugin)->plugin_class = plugin->world->lv2_plugin_class;
@@ -453,11 +449,11 @@ lilv_plugin_get_class(const LilvPlugin* plugin)
 
 static LilvNodes*
 lilv_plugin_get_value_internal(const LilvPlugin* plugin,
-                               const SordNode*   predicate)
+                               const SerdNode*   predicate)
 {
   lilv_plugin_load_if_necessary(plugin);
   return lilv_world_find_nodes_internal(
-    plugin->world, plugin->plugin_uri->node, predicate, NULL);
+    plugin->world, plugin->plugin_uri, predicate, NULL);
 }
 
 bool
@@ -468,9 +464,7 @@ lilv_plugin_verify(const LilvPlugin* plugin)
     return false;
   }
 
-  LilvNode*  rdf_type = lilv_new_uri(plugin->world, LILV_NS_RDF "type");
-  LilvNodes* results  = lilv_plugin_get_value(plugin, rdf_type);
-  lilv_node_free(rdf_type);
+  LilvNodes* results = lilv_plugin_get_value(plugin, plugin->world->uris.rdf_a);
   if (!results) {
     return false;
   }
@@ -637,57 +631,47 @@ bool
 lilv_plugin_has_latency(const LilvPlugin* plugin)
 {
   lilv_plugin_load_if_necessary(plugin);
-  SordIter* ports = lilv_world_query_internal(plugin->world,
-                                              plugin->plugin_uri->node,
-                                              plugin->world->uris.lv2_port,
-                                              NULL);
+
+  SerdRange* ports = serd_model_range(plugin->world->model,
+                                      plugin->plugin_uri,
+                                      plugin->world->uris.lv2_port,
+                                      NULL,
+                                      NULL);
 
   bool ret = false;
-  FOREACH_MATCH (ports) {
-    const SordNode* port = sord_iter_get_node(ports, SORD_OBJECT);
-
-    SordIter* prop =
-      lilv_world_query_internal(plugin->world,
-                                port,
-                                plugin->world->uris.lv2_portProperty,
-                                plugin->world->uris.lv2_reportsLatency);
-
-    SordIter* des =
-      lilv_world_query_internal(plugin->world,
-                                port,
-                                plugin->world->uris.lv2_designation,
-                                plugin->world->uris.lv2_latency);
-
-    const bool latent = !sord_iter_end(prop) || !sord_iter_end(des);
-    sord_iter_free(prop);
-    sord_iter_free(des);
-    if (latent) {
+  FOREACH_MATCH (s, ports) {
+    const SerdNode* port = serd_statement_object(s);
+    if (serd_model_ask(plugin->world->model,
+                       port,
+                       plugin->world->uris.lv2_portProperty,
+                       plugin->world->uris.lv2_reportsLatency,
+                       NULL) ||
+        serd_model_ask(plugin->world->model,
+                       port,
+                       plugin->world->uris.lv2_designation,
+                       plugin->world->uris.lv2_latency,
+                       NULL)) {
       ret = true;
       break;
     }
   }
-  sord_iter_free(ports);
+  serd_range_free(ports);
 
   return ret;
 }
 
 static const LilvPort*
 lilv_plugin_get_port_by_property(const LilvPlugin* plugin,
-                                 const SordNode*   port_property)
+                                 const SerdNode*   port_property)
 {
   lilv_plugin_load_ports_if_necessary(plugin);
   for (uint32_t i = 0; i < plugin->num_ports; ++i) {
     LilvPort* port = plugin->ports[i];
-    SordIter* iter =
-      lilv_world_query_internal(plugin->world,
-                                port->node->node,
-                                plugin->world->uris.lv2_portProperty,
-                                port_property);
-
-    const bool found = !sord_iter_end(iter);
-    sord_iter_free(iter);
-
-    if (found) {
+    if (serd_model_ask(plugin->world->model,
+                       port->node,
+                       plugin->world->uris.lv2_portProperty,
+                       port_property,
+                       NULL)) {
       return port;
     }
   }
@@ -703,16 +687,12 @@ lilv_plugin_get_port_by_designation(const LilvPlugin* plugin,
   LilvWorld* world = plugin->world;
   lilv_plugin_load_ports_if_necessary(plugin);
   for (uint32_t i = 0; i < plugin->num_ports; ++i) {
-    LilvPort* port = plugin->ports[i];
-    SordIter* iter = lilv_world_query_internal(
-      world, port->node->node, world->uris.lv2_designation, designation->node);
-
-    const bool found =
-      !sord_iter_end(iter) &&
-      (!port_class || lilv_port_is_a(plugin, port, port_class));
-    sord_iter_free(iter);
+    LilvPort*  port            = plugin->ports[i];
+    const bool has_designation = serd_model_ask(
+      world->model, port->node, world->uris.lv2_designation, designation, NULL);
 
-    if (found) {
+    if (has_designation &&
+        (!port_class || lilv_port_is_a(plugin, port, port_class))) {
       return port;
     }
   }
@@ -749,13 +729,13 @@ bool
 lilv_plugin_has_feature(const LilvPlugin* plugin, const LilvNode* feature)
 {
   lilv_plugin_load_if_necessary(plugin);
-  const SordNode* predicates[] = {plugin->world->uris.lv2_requiredFeature,
+  const SerdNode* predicates[] = {plugin->world->uris.lv2_requiredFeature,
                                   plugin->world->uris.lv2_optionalFeature,
                                   NULL};
 
-  for (const SordNode** pred = predicates; *pred; ++pred) {
-    if (lilv_world_ask_internal(
-          plugin->world, plugin->plugin_uri->node, *pred, feature->node)) {
+  for (const SerdNode** pred = predicates; *pred; ++pred) {
+    if (serd_model_ask(
+          plugin->world->model, plugin->plugin_uri, *pred, feature, NULL)) {
       return true;
     }
   }
@@ -778,7 +758,7 @@ lilv_plugin_get_optional_features(const LilvPlugin* plugin)
 {
   lilv_plugin_load_if_necessary(plugin);
   return lilv_world_find_nodes_internal(plugin->world,
-                                        plugin->plugin_uri->node,
+                                        plugin->plugin_uri,
                                         plugin->world->uris.lv2_optionalFeature,
                                         NULL);
 }
@@ -788,7 +768,7 @@ lilv_plugin_get_required_features(const LilvPlugin* plugin)
 {
   lilv_plugin_load_if_necessary(plugin);
   return lilv_world_find_nodes_internal(plugin->world,
-                                        plugin->plugin_uri->node,
+                                        plugin->plugin_uri,
                                         plugin->world->uris.lv2_requiredFeature,
                                         NULL);
 }
@@ -797,16 +777,16 @@ bool
 lilv_plugin_has_extension_data(const LilvPlugin* plugin, const LilvNode* uri)
 {
   if (!lilv_node_is_uri(uri)) {
-    LILV_ERRORF("Extension data `%s' is not a URI\n",
-                sord_node_get_string(uri->node));
+    LILV_ERRORF("Extension data `%s' is not a URI\n", serd_node_string(uri));
     return false;
   }
 
   lilv_plugin_load_if_necessary(plugin);
-  return lilv_world_ask_internal(plugin->world,
-                                 plugin->plugin_uri->node,
-                                 plugin->world->uris.lv2_extensionData,
-                                 uri->node);
+  return serd_model_ask(plugin->world->model,
+                        plugin->plugin_uri,
+                        plugin->world->uris.lv2_extensionData,
+                        uri,
+                        NULL);
 }
 
 LilvNodes*
@@ -846,73 +826,51 @@ lilv_plugin_get_project(const LilvPlugin* plugin)
 {
   lilv_plugin_load_if_necessary(plugin);
 
-  SordNode* lv2_project =
-    sord_new_uri(plugin->world->world, (const uint8_t*)LV2_CORE__project);
-
-  SordIter* projects = lilv_world_query_internal(
-    plugin->world, plugin->plugin_uri->node, lv2_project, NULL);
-
-  sord_node_free(plugin->world->world, lv2_project);
-
-  if (sord_iter_end(projects)) {
-    sord_iter_free(projects);
-    return NULL;
-  }
-
-  const SordNode* project = sord_iter_get_node(projects, SORD_OBJECT);
-
-  sord_iter_free(projects);
-  return lilv_node_new_from_node(plugin->world, project);
+  return serd_node_copy(serd_model_get(plugin->world->model,
+                                       plugin->plugin_uri,
+                                       plugin->world->uris.lv2_project,
+                                       NULL,
+                                       NULL));
 }
 
-static const SordNode*
+static SerdNode*
 lilv_plugin_get_author(const LilvPlugin* plugin)
 {
   lilv_plugin_load_if_necessary(plugin);
 
-  SordNode* doap_maintainer =
-    sord_new_uri(plugin->world->world, NS_DOAP "maintainer");
-
-  SordIter* maintainers = lilv_world_query_internal(
-    plugin->world, plugin->plugin_uri->node, doap_maintainer, NULL);
+  SerdNode* doap_maintainer =
+    serd_new_uri(SERD_STATIC_STRING(NS_DOAP "maintainer"));
 
-  if (sord_iter_end(maintainers)) {
-    sord_iter_free(maintainers);
+  const SerdNode* maintainer = serd_model_get(
+    plugin->world->model, plugin->plugin_uri, doap_maintainer, NULL, NULL);
 
+  if (!maintainer) {
     LilvNode* project = lilv_plugin_get_project(plugin);
     if (!project) {
-      sord_node_free(plugin->world->world, doap_maintainer);
+      serd_node_free(doap_maintainer);
       return NULL;
     }
 
-    maintainers = lilv_world_query_internal(
-      plugin->world, project->node, doap_maintainer, NULL);
+    maintainer = serd_model_get(
+      plugin->world->model, project, doap_maintainer, NULL, NULL);
 
     lilv_node_free(project);
   }
 
-  sord_node_free(plugin->world->world, doap_maintainer);
+  serd_node_free(doap_maintainer);
 
-  if (sord_iter_end(maintainers)) {
-    sord_iter_free(maintainers);
-    return NULL;
-  }
-
-  const SordNode* author = sord_iter_get_node(maintainers, SORD_OBJECT);
-
-  sord_iter_free(maintainers);
-  return author;
+  return maintainer ? serd_node_copy(maintainer) : NULL;
 }
 
 static LilvNode*
-lilv_plugin_get_author_property(const LilvPlugin* plugin, const uint8_t* uri)
+lilv_plugin_get_author_property(const LilvPlugin* plugin, const char* uri)
 {
-  const SordNode* author = lilv_plugin_get_author(plugin);
+  SerdNode* author = lilv_plugin_get_author(plugin);
   if (author) {
-    SordWorld* sworld = plugin->world->world;
-    SordNode*  pred   = sord_new_uri(sworld, uri);
-    LilvNode*  ret    = lilv_plugin_get_one(plugin, author, pred);
-    sord_node_free(sworld, pred);
+    SerdNode* pred = serd_new_uri(SERD_MEASURE_STRING(uri));
+    LilvNode* ret  = lilv_plugin_get_one(plugin, author, pred);
+    serd_node_free(pred);
+    serd_node_free(author);
     return ret;
   }
   return NULL;
@@ -947,17 +905,15 @@ lilv_plugin_get_uis(const LilvPlugin* plugin)
 {
   lilv_plugin_load_if_necessary(plugin);
 
-  SordNode* ui_ui_node =
-    sord_new_uri(plugin->world->world, (const uint8_t*)LV2_UI__ui);
-  SordNode* ui_binary_node =
-    sord_new_uri(plugin->world->world, (const uint8_t*)LV2_UI__binary);
+  SerdNode* ui_ui_node     = serd_new_uri(SERD_STATIC_STRING(LV2_UI__ui));
+  SerdNode* ui_binary_node = serd_new_uri(SERD_STATIC_STRING(LV2_UI__binary));
 
-  LilvUIs*  result = lilv_uis_new();
-  SordIter* uis    = lilv_world_query_internal(
-    plugin->world, plugin->plugin_uri->node, ui_ui_node, NULL);
+  LilvUIs*   result = lilv_uis_new();
+  SerdRange* uis    = serd_model_range(
+    plugin->world->model, plugin->plugin_uri, ui_ui_node, NULL, NULL);
 
-  FOREACH_MATCH (uis) {
-    const SordNode* ui = sord_iter_get_node(uis, SORD_OBJECT);
+  FOREACH_MATCH (s, uis) {
+    const SerdNode* ui = serd_statement_object(s);
 
     LilvNode* type =
       lilv_plugin_get_unique(plugin, ui, plugin->world->uris.rdf_a);
@@ -967,30 +923,30 @@ lilv_plugin_get_uis(const LilvPlugin* plugin)
       binary = lilv_plugin_get_unique(plugin, ui, ui_binary_node);
     }
 
-    if (sord_node_get_type(ui) != SORD_URI || !lilv_node_is_uri(type) ||
+    if (serd_node_type(ui) != SERD_URI || !lilv_node_is_uri(type) ||
         !lilv_node_is_uri(binary)) {
       lilv_node_free(binary);
       lilv_node_free(type);
-      LILV_ERRORF("Corrupt UI <%s>\n", sord_node_get_string(ui));
+      LILV_ERRORF("Corrupt UI <%s>\n", serd_node_string(ui));
       continue;
     }
 
-    LilvUI* lilv_ui = lilv_ui_new(
-      plugin->world, lilv_node_new_from_node(plugin->world, ui), type, binary);
+    LilvUI* lilv_ui =
+      lilv_ui_new(plugin->world, serd_node_copy(ui), type, binary);
 
     zix_tree_insert((ZixTree*)result, lilv_ui, NULL);
   }
-  sord_iter_free(uis);
+  serd_range_free(uis);
 
-  sord_node_free(plugin->world->world, ui_binary_node);
-  sord_node_free(plugin->world->world, ui_ui_node);
+  serd_node_free(ui_binary_node);
+  serd_node_free(ui_ui_node);
 
   if (lilv_uis_size(result) > 0) {
     return result;
+  } else {
+    lilv_uis_free(result);
+    return NULL;
   }
-
-  lilv_uis_free(result);
-  return NULL;
 }
 
 LilvNodes*
@@ -1000,7 +956,7 @@ lilv_plugin_get_related(const LilvPlugin* plugin, const LilvNode* type)
 
   LilvWorld* const world   = plugin->world;
   LilvNodes* const related = lilv_world_find_nodes_internal(
-    world, NULL, world->uris.lv2_appliesTo, lilv_plugin_get_uri(plugin)->node);
+    world, NULL, world->uris.lv2_appliesTo, lilv_plugin_get_uri(plugin));
 
   if (!type) {
     return related;
@@ -1009,10 +965,8 @@ lilv_plugin_get_related(const LilvPlugin* plugin, const LilvNode* type)
   LilvNodes* matches = lilv_nodes_new();
   LILV_FOREACH (nodes, i, related) {
     LilvNode* node = (LilvNode*)lilv_collection_get((ZixTree*)related, i);
-    if (lilv_world_ask_internal(
-          world, node->node, world->uris.rdf_a, type->node)) {
-      zix_tree_insert(
-        (ZixTree*)matches, lilv_node_new_from_node(world, node->node), NULL);
+    if (serd_model_ask(world->model, node, world->uris.rdf_a, type, NULL)) {
+      zix_tree_insert((ZixTree*)matches, serd_node_copy(node), NULL);
     }
   }
 
@@ -1023,27 +977,32 @@ lilv_plugin_get_related(const LilvPlugin* plugin, const LilvNode* type)
 static SerdEnv*
 new_lv2_env(const SerdNode* base)
 {
-  SerdEnv* env = serd_env_new(base);
-
-#define USTR(s) ((const uint8_t*)(s))
-
-  serd_env_set_prefix_from_strings(env, USTR("doap"), USTR(LILV_NS_DOAP));
-  serd_env_set_prefix_from_strings(env, USTR("foaf"), USTR(LILV_NS_FOAF));
-  serd_env_set_prefix_from_strings(env, USTR("lv2"), USTR(LILV_NS_LV2));
-  serd_env_set_prefix_from_strings(env, USTR("owl"), USTR(LILV_NS_OWL));
-  serd_env_set_prefix_from_strings(env, USTR("rdf"), USTR(LILV_NS_RDF));
-  serd_env_set_prefix_from_strings(env, USTR("rdfs"), USTR(LILV_NS_RDFS));
-  serd_env_set_prefix_from_strings(env, USTR("xsd"), USTR(LILV_NS_XSD));
+  SerdEnv* env = serd_env_new(serd_node_string_view(base));
+
+  serd_env_set_prefix(
+    env, SERD_STATIC_STRING("doap"), SERD_STATIC_STRING(NS_DOAP));
+  serd_env_set_prefix(
+    env, SERD_STATIC_STRING("foaf"), SERD_STATIC_STRING(NS_FOAF));
+  serd_env_set_prefix(
+    env, SERD_STATIC_STRING("lv2"), SERD_STATIC_STRING(NS_LV2));
+  serd_env_set_prefix(
+    env, SERD_STATIC_STRING("owl"), SERD_STATIC_STRING(NS_OWL));
+  serd_env_set_prefix(
+    env, SERD_STATIC_STRING("rdf"), SERD_STATIC_STRING(NS_RDF));
+  serd_env_set_prefix(
+    env, SERD_STATIC_STRING("rdfs"), SERD_STATIC_STRING(NS_RDFS));
+  serd_env_set_prefix(
+    env, SERD_STATIC_STRING("xsd"), SERD_STATIC_STRING(NS_XSD));
 
   return env;
 }
 
 static void
-maybe_write_prefixes(SerdWriter* writer, SerdEnv* env, FILE* file)
+maybe_write_prefixes(const SerdSink* sink, SerdEnv* env, FILE* file)
 {
   fseek(file, 0, SEEK_END);
   if (ftell(file) == 0) {
-    serd_env_foreach(env, (SerdPrefixSink)serd_writer_set_prefix, writer);
+    serd_env_write_prefixes(env, sink);
   } else {
     fprintf(file, "\n");
   }
@@ -1057,31 +1016,30 @@ lilv_plugin_write_description(LilvWorld*        world,
 {
   const LilvNode* subject   = lilv_plugin_get_uri(plugin);
   const uint32_t  num_ports = lilv_plugin_get_num_ports(plugin);
-  const SerdNode* base      = sord_node_to_serd_node(base_uri->node);
+  const SerdNode* base      = base_uri;
   SerdEnv*        env       = new_lv2_env(base);
 
-  SerdWriter* writer =
-    serd_writer_new(SERD_TURTLE,
-                    (SerdStyle)(SERD_STYLE_ABBREVIATED | SERD_STYLE_CURIED),
-                    env,
-                    NULL,
-                    serd_file_sink,
-                    plugin_file);
+  SerdByteSink* const sink =
+    serd_byte_sink_new_function((SerdWriteFunc)fwrite, plugin_file, 1);
+
+  SerdWriter* writer = serd_writer_new(world->world, SERD_TURTLE, 0, env, sink);
+
+  const SerdSink* iface = serd_writer_sink(writer);
 
   // Write prefixes if this is a new file
-  maybe_write_prefixes(writer, env, plugin_file);
+  maybe_write_prefixes(iface, env, plugin_file);
 
   // Write plugin description
-  SordIter* plug_iter =
-    lilv_world_query_internal(world, subject->node, NULL, NULL);
-  sord_write_iter(plug_iter, writer);
+  SerdRange* plug_range =
+    serd_model_range(world->model, subject, NULL, NULL, NULL);
+  serd_range_serialise(plug_range, iface, 0);
 
   // Write port descriptions
   for (uint32_t i = 0; i < num_ports; ++i) {
     const LilvPort* port = plugin->ports[i];
-    SordIter*       port_iter =
-      lilv_world_query_internal(world, port->node->node, NULL, NULL);
-    sord_write_iter(port_iter, writer);
+    SerdRange*      port_range =
+      serd_model_range(world->model, port->node, NULL, NULL, NULL);
+    serd_range_serialise(port_range, iface, 0);
   }
 
   serd_writer_free(writer);
@@ -1095,45 +1053,37 @@ lilv_plugin_write_manifest_entry(LilvWorld*        world,
                                  FILE*             manifest_file,
                                  const char*       plugin_file_path)
 {
-  (void)world;
-
   const LilvNode* subject = lilv_plugin_get_uri(plugin);
-  const SerdNode* base    = sord_node_to_serd_node(base_uri->node);
+  const SerdNode* base    = base_uri;
   SerdEnv*        env     = new_lv2_env(base);
 
-  SerdWriter* writer =
-    serd_writer_new(SERD_TURTLE,
-                    (SerdStyle)(SERD_STYLE_ABBREVIATED | SERD_STYLE_CURIED),
-                    env,
-                    NULL,
-                    serd_file_sink,
-                    manifest_file);
+  SerdByteSink* const sink =
+    serd_byte_sink_new_function((SerdWriteFunc)fwrite, manifest_file, 1);
+
+  SerdWriter* writer = serd_writer_new(world->world, SERD_TURTLE, 0, env, sink);
+
+  const SerdSink* iface = serd_writer_sink(writer);
 
   // Write prefixes if this is a new file
-  maybe_write_prefixes(writer, env, manifest_file);
+  maybe_write_prefixes(iface, env, manifest_file);
 
   // Write manifest entry
-  serd_writer_write_statement(
-    writer,
-    0,
-    NULL,
-    sord_node_to_serd_node(subject->node),
-    sord_node_to_serd_node(plugin->world->uris.rdf_a),
-    sord_node_to_serd_node(plugin->world->uris.lv2_Plugin),
-    0,
-    0);
-
-  const SerdNode file_node =
-    serd_node_from_string(SERD_URI, (const uint8_t*)plugin_file_path);
-  serd_writer_write_statement(
-    writer,
-    0,
-    NULL,
-    sord_node_to_serd_node(subject->node),
-    sord_node_to_serd_node(plugin->world->uris.rdfs_seeAlso),
-    &file_node,
-    0,
-    0);
+  serd_sink_write(iface,
+                  0,
+                  subject,
+                  plugin->world->uris.rdf_a,
+                  plugin->world->uris.lv2_Plugin,
+                  NULL);
+
+  const SerdNode* file_node =
+    serd_new_uri(SERD_MEASURE_STRING(plugin_file_path));
+
+  serd_sink_write(serd_writer_sink(writer),
+                  0,
+                  subject,
+                  plugin->world->uris.rdfs_seeAlso,
+                  file_node,
+                  NULL);
 
   serd_writer_free(writer);
   serd_env_free(env);