WIP: Port to serd1 and rework API

3 files changed, 1065 insertions, 924 deletions

diff --git a/src/dumper.c b/src/dumper.c
new file mode 100644
index 0000000..b2bb852
--- /dev/null
+++ b/src/dumper.c
@@ -0,0 +1,546 @@
+/*
+  Copyright 2012-2021 David Robillard <d@drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include "sratom/sratom.h"
+
+#include "lv2/atom/atom.h"
+#include "lv2/atom/forge.h"
+#include "lv2/atom/util.h"
+#include "lv2/midi/midi.h"
+#include "lv2/urid/urid.h"
+#include "serd/serd.h"
+
+#include <ctype.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define NS_RDF "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+#define NS_XSD "http://www.w3.org/2001/XMLSchema#"
+
+#define STREAM_WARN(msg) \
+  serd_world_logf(       \
+    writer->world, "sratom", SERD_LOG_LEVEL_WARNING, 0, NULL, msg);
+
+#define STREAM_ERRORF(msg, ...) \
+  serd_world_logf(              \
+    writer->world, "sratom", SERD_LOG_LEVEL_ERROR, 0, NULL, msg, __VA_ARGS__);
+
+struct SratomDumperImpl {
+  LV2_URID_Unmap* unmap;
+  LV2_Atom_Forge  forge;
+  SerdWorld*      world;
+  LV2_URID        atom_Event;
+  LV2_URID        atom_beatTime;
+  LV2_URID        midi_MidiEvent;
+  struct {
+    const SerdNode* atom_Path;
+    const SerdNode* atom_beatTime;
+    const SerdNode* atom_childType;
+    const SerdNode* atom_frameTime;
+    const SerdNode* midi_MidiEvent;
+    const SerdNode* rdf_first;
+    const SerdNode* rdf_nil;
+    const SerdNode* rdf_rest;
+    const SerdNode* rdf_type;
+    const SerdNode* rdf_value;
+    const SerdNode* xsd_base64Binary;
+    const SerdNode* xsd_boolean;
+    const SerdNode* xsd_decimal;
+    const SerdNode* xsd_double;
+    const SerdNode* xsd_float;
+    const SerdNode* xsd_int;
+    const SerdNode* xsd_integer;
+    const SerdNode* xsd_long;
+  } nodes;
+};
+
+typedef struct {
+  SratomDumper*           writer;
+  const SerdEnv*          env;
+  const SerdSink*         sink;
+  const SratomDumperFlags flags;
+  SerdStatementFlags      sflags;
+  LV2_URID                seq_unit;
+} StreamContext;
+
+void
+sratom_free(void* ptr)
+{
+  /* The only sratom memory the user frees comes from sratom_from_model(),
+     which is allocated by serd_buffer_sink. */
+  serd_free(ptr);
+}
+
+SratomDumper*
+sratom_dumper_new(SerdWorld* const      world,
+                  LV2_URID_Map* const   map,
+                  LV2_URID_Unmap* const unmap)
+{
+  SratomDumper* writer = (SratomDumper*)calloc(1, sizeof(SratomDumper));
+  if (!writer) {
+    return NULL;
+  }
+
+  writer->world          = world;
+  writer->unmap          = unmap;
+  writer->atom_Event     = map->map(map->handle, LV2_ATOM__Event);
+  writer->atom_beatTime  = map->map(map->handle, LV2_ATOM__beatTime);
+  writer->midi_MidiEvent = map->map(map->handle, LV2_MIDI__MidiEvent);
+  lv2_atom_forge_init(&writer->forge, map);
+
+#define MANAGE_URI(uri)                      \
+  serd_nodes_manage(serd_world_nodes(world), \
+                    serd_new_uri(SERD_STATIC_STRING(uri)))
+
+  writer->nodes.atom_Path        = MANAGE_URI(LV2_ATOM__Path);
+  writer->nodes.atom_beatTime    = MANAGE_URI(LV2_ATOM__beatTime);
+  writer->nodes.atom_childType   = MANAGE_URI(LV2_ATOM__childType);
+  writer->nodes.atom_frameTime   = MANAGE_URI(LV2_ATOM__frameTime);
+  writer->nodes.midi_MidiEvent   = MANAGE_URI(LV2_MIDI__MidiEvent);
+  writer->nodes.rdf_first        = MANAGE_URI(NS_RDF "first");
+  writer->nodes.rdf_nil          = MANAGE_URI(NS_RDF "nil");
+  writer->nodes.rdf_rest         = MANAGE_URI(NS_RDF "rest");
+  writer->nodes.rdf_type         = MANAGE_URI(NS_RDF "type");
+  writer->nodes.rdf_value        = MANAGE_URI(NS_RDF "value");
+  writer->nodes.xsd_base64Binary = MANAGE_URI(NS_XSD "base64Binary");
+  writer->nodes.xsd_boolean      = MANAGE_URI(NS_XSD "boolean");
+  writer->nodes.xsd_decimal      = MANAGE_URI(NS_XSD "decimal");
+  writer->nodes.xsd_double       = MANAGE_URI(NS_XSD "double");
+  writer->nodes.xsd_float        = MANAGE_URI(NS_XSD "float");
+  writer->nodes.xsd_int          = MANAGE_URI(NS_XSD "int");
+  writer->nodes.xsd_integer      = MANAGE_URI(NS_XSD "integer");
+  writer->nodes.xsd_long         = MANAGE_URI(NS_XSD "long");
+
+#undef MANAGE_URI
+
+  return writer;
+}
+
+void
+sratom_dumper_free(SratomDumper* writer)
+{
+  free(writer);
+}
+
+static int
+write_atom(StreamContext*  ctx,
+           const SerdNode* subject,
+           const SerdNode* predicate,
+           LV2_URID        type,
+           uint32_t        size,
+           const void*     body);
+
+static void
+list_append(StreamContext*   ctx,
+            SerdNode**       s,
+            const SerdNode** p,
+            uint32_t         size,
+            uint32_t         type,
+            const void*      body)
+{
+  // Generate a list node
+  SerdNode* node = serd_node_copy(serd_world_get_blank(ctx->writer->world));
+  serd_sink_write(ctx->sink, ctx->sflags, *s, *p, node, NULL);
+
+  // _:node rdf:first value
+  ctx->sflags = 0;
+  *p          = ctx->writer->nodes.rdf_first;
+  write_atom(ctx, node, *p, type, size, body);
+
+  // Set subject to node and predicate to rdf:rest for next time
+  serd_node_free(*s);
+  *s = node;
+  *p = ctx->writer->nodes.rdf_rest;
+}
+
+static void
+list_end(StreamContext* ctx, const SerdNode* s, const SerdNode* p)
+{
+  // _:node rdf:rest rdf:nil
+  serd_sink_write(
+    ctx->sink, ctx->sflags, s, p, ctx->writer->nodes.rdf_nil, NULL);
+}
+
+static void
+start_object(StreamContext*  ctx,
+             const SerdNode* subject,
+             const SerdNode* predicate,
+             const SerdNode* node,
+             const char*     type)
+{
+  if (subject && predicate) {
+    serd_sink_write(
+      ctx->sink, ctx->sflags | SERD_ANON_O, subject, predicate, node, NULL);
+  } else {
+    ctx->sflags |= SERD_EMPTY_S;
+  }
+
+  if (type) {
+    SerdNode* o = serd_new_uri(SERD_MEASURE_STRING(type));
+
+    serd_sink_write(
+      ctx->sink, ctx->sflags, node, ctx->writer->nodes.rdf_type, o, NULL);
+
+    serd_node_free(o);
+  }
+}
+
+static void
+end_object(StreamContext*  ctx,
+           const SerdNode* subject,
+           const SerdNode* predicate,
+           const SerdNode* node)
+{
+  if (subject && predicate) {
+    serd_sink_write_end(ctx->sink, node);
+  }
+}
+
+static bool
+path_is_absolute(const char* path)
+{
+  return (path[0] == '/' || (isalpha(path[0]) && path[1] == ':' &&
+                             (path[2] == '/' || path[2] == '\\')));
+}
+
+static const SerdNode*
+number_type(StreamContext* ctx, const SerdNode* type)
+{
+  SratomDumper* const writer = ctx->writer;
+  const bool          pretty = (ctx->flags & SRATOM_PRETTY_NUMBERS);
+  if (pretty) {
+    if (type == writer->nodes.xsd_int || type == writer->nodes.xsd_long) {
+      return writer->nodes.xsd_integer;
+    } else if (type == writer->nodes.xsd_float ||
+               type == writer->nodes.xsd_double) {
+      return writer->nodes.xsd_decimal;
+    }
+  }
+  return type;
+}
+
+static bool
+is_primitive_type(StreamContext* ctx, const LV2_URID type)
+{
+  SratomDumper* const writer = ctx->writer;
+  return (!type || type == writer->forge.Bool || type == writer->forge.Double ||
+          type == writer->forge.Float || type == writer->forge.Int ||
+          type == writer->forge.Literal || type == writer->forge.Long ||
+          type == writer->forge.Path || type == writer->forge.String ||
+          type == writer->forge.URI || type == writer->forge.URID);
+}
+
+static int
+write_atom(StreamContext* const ctx,
+           const SerdNode*      subject,
+           const SerdNode*      predicate,
+           const LV2_URID       type,
+           const uint32_t       size,
+           const void* const    body)
+{
+  SratomDumper*     writer   = ctx->writer;
+  LV2_URID_Unmap*   unmap    = writer->unmap;
+  const SerdSink*   sink     = ctx->sink;
+  const SerdEnv*    env      = ctx->env;
+  const char* const type_uri = unmap->unmap(unmap->handle, type);
+  SerdNode*         object   = NULL;
+  if (type == 0 && size == 0) {
+    object = serd_node_copy(writer->nodes.rdf_nil);
+  } else if (type == writer->forge.String) {
+    object = serd_new_string(SERD_MEASURE_STRING((const char*)body));
+  } else if (type == writer->forge.Chunk) {
+    object = serd_new_blob(body, size, NULL);
+  } else if (type == writer->forge.Literal) {
+    const LV2_Atom_Literal_Body* lit = (const LV2_Atom_Literal_Body*)body;
+    const char*                  str = (const char*)(lit + 1);
+    if (lit->datatype) {
+      const SerdStringView datatype_uri =
+        SERD_MEASURE_STRING(unmap->unmap(unmap->handle, lit->datatype));
+      object = serd_new_typed_literal(SERD_MEASURE_STRING(str), datatype_uri);
+    } else if (lit->lang) {
+      const char*  lang       = unmap->unmap(unmap->handle, lit->lang);
+      const char*  prefix     = "http://lexvo.org/id/iso639-3/";
+      const size_t prefix_len = strlen(prefix);
+      if (lang && !strncmp(lang, prefix, prefix_len)) {
+        object = serd_new_plain_literal(SERD_MEASURE_STRING(str),
+                                        SERD_MEASURE_STRING(lang + prefix_len));
+      } else {
+        STREAM_ERRORF("Unknown language URID %u\n", lit->lang);
+      }
+    }
+  } else if (type == writer->forge.URID) {
+    const uint32_t urid = *(const uint32_t*)body;
+    const char*    str  = unmap->unmap(unmap->handle, urid);
+
+    object = serd_new_uri(SERD_MEASURE_STRING(str));
+  } else if (type == writer->forge.Path) {
+    const SerdStringView str = SERD_MEASURE_STRING((const char*)body);
+    if (path_is_absolute(str.buf)) {
+      object = serd_new_file_uri(str, SERD_EMPTY_STRING());
+    } else {
+      const SerdNode* base_uri = serd_env_base_uri(env);
+      if (!base_uri || strncmp(serd_node_string(base_uri), "file://", 7)) {
+        STREAM_WARN("Relative path but base is not a file URI.\n");
+        STREAM_WARN("Writing ambiguous atom:Path literal.\n");
+        object = serd_new_typed_literal(
+          str, serd_node_string_view(writer->nodes.atom_Path));
+      } else {
+        SerdNode* const rel = serd_new_file_uri(str, SERD_EMPTY_STRING());
+
+        object = serd_new_parsed_uri(serd_resolve_uri(
+          serd_node_uri_view(rel), serd_node_uri_view(base_uri)));
+
+        serd_node_free(rel);
+      }
+    }
+  } else if (type == writer->forge.URI) {
+    object = serd_new_uri(SERD_MEASURE_STRING((const char*)body));
+  } else if (type == writer->forge.Int) {
+    object = serd_new_integer(*(const int32_t*)body,
+                              number_type(ctx, writer->nodes.xsd_int));
+  } else if (type == writer->forge.Long) {
+    object = serd_new_integer(*(const int64_t*)body,
+                              number_type(ctx, writer->nodes.xsd_long));
+  } else if (type == writer->forge.Float) {
+    object = serd_new_decimal(*(const float*)body,
+                              number_type(ctx, writer->nodes.xsd_float));
+  } else if (type == writer->forge.Double) {
+    object = serd_new_decimal(*(const double*)body,
+                              number_type(ctx, writer->nodes.xsd_double));
+  } else if (type == writer->forge.Bool) {
+    object = serd_new_boolean(*(const int32_t*)body);
+  } else if (type == writer->midi_MidiEvent) {
+    const size_t len = 2 * size;
+    char* const  str = (char*)calloc(len + 1, 1);
+    for (uint32_t i = 0; i < size; ++i) {
+      snprintf(str + (2 * i),
+               size * 2 + 1,
+               "%02X",
+               (unsigned)*((const uint8_t*)body + i));
+    }
+
+    object = serd_new_typed_literal(
+      SERD_STRING_VIEW(str, len),
+      serd_node_string_view(writer->nodes.midi_MidiEvent));
+
+    free(str);
+  } else if (type == writer->atom_Event) {
+    const LV2_Atom_Event* ev = (const LV2_Atom_Event*)body;
+    const SerdNode*       id = serd_world_get_blank(writer->world);
+    start_object(ctx, subject, predicate, id, NULL);
+    SerdNode*       time = NULL;
+    const SerdNode* p    = NULL;
+    if (ctx->seq_unit == writer->atom_beatTime) {
+      p    = writer->nodes.atom_beatTime;
+      time = serd_new_double(ev->time.beats);
+    } else {
+      p    = writer->nodes.atom_frameTime;
+      time = serd_new_integer(ev->time.frames,
+                              number_type(ctx, writer->nodes.xsd_long));
+    }
+    serd_sink_write(sink, 0, id, p, time, NULL);
+    serd_node_free(time);
+
+    p = writer->nodes.rdf_value;
+    write_atom(
+      ctx, id, p, ev->body.type, ev->body.size, LV2_ATOM_BODY_CONST(&ev->body));
+    end_object(ctx, subject, predicate, id);
+  } else if (type == writer->forge.Tuple) {
+    SerdNode* id = serd_node_copy(serd_world_get_blank(writer->world));
+    start_object(ctx, subject, predicate, id, type_uri);
+    const SerdNode* p = writer->nodes.rdf_value;
+    ctx->sflags |= SERD_LIST_O | SERD_TERSE_O;
+    LV2_ATOM_TUPLE_BODY_FOREACH (body, size, i) {
+      if (!is_primitive_type(ctx, i->type)) {
+        ctx->sflags &= ~SERD_TERSE_O;
+      }
+    }
+    LV2_ATOM_TUPLE_BODY_FOREACH (body, size, i) {
+      list_append(ctx, &id, &p, i->size, i->type, LV2_ATOM_BODY(i));
+    }
+    list_end(ctx, id, p);
+    end_object(ctx, subject, predicate, id);
+    serd_node_free(id);
+  } else if (type == writer->forge.Vector) {
+    const LV2_Atom_Vector_Body* vec = (const LV2_Atom_Vector_Body*)body;
+    SerdNode* id = serd_node_copy(serd_world_get_blank(writer->world));
+    start_object(ctx, subject, predicate, id, type_uri);
+    const SerdNode* p          = writer->nodes.atom_childType;
+    SerdNode*       child_type = serd_new_uri(
+      SERD_MEASURE_STRING(unmap->unmap(unmap->handle, vec->child_type)));
+    serd_sink_write(sink, ctx->sflags, id, p, child_type, NULL);
+    p = writer->nodes.rdf_value;
+    serd_node_free(child_type);
+    ctx->sflags |= SERD_LIST_O;
+    if (is_primitive_type(ctx, vec->child_type)) {
+      ctx->sflags |= SERD_TERSE_O;
+    }
+    for (const char* i = (const char*)(vec + 1); i < (const char*)vec + size;
+         i += vec->child_size) {
+      list_append(ctx, &id, &p, vec->child_size, vec->child_type, i);
+    }
+    list_end(ctx, id, p);
+    end_object(ctx, subject, predicate, id);
+    serd_node_free(id);
+  } else if (lv2_atom_forge_is_object_type(&writer->forge, type)) {
+    const LV2_Atom_Object_Body* obj   = (const LV2_Atom_Object_Body*)body;
+    const char*                 otype = unmap->unmap(unmap->handle, obj->otype);
+
+    SerdNode* id = NULL;
+    if (lv2_atom_forge_is_blank(&writer->forge, type, obj)) {
+      id = serd_node_copy(serd_world_get_blank(writer->world));
+      start_object(ctx, subject, predicate, id, otype);
+    } else {
+      id =
+        serd_new_uri(SERD_MEASURE_STRING(unmap->unmap(unmap->handle, obj->id)));
+      ctx->sflags = 0;
+      start_object(ctx, NULL, NULL, id, otype);
+    }
+    LV2_ATOM_OBJECT_BODY_FOREACH (obj, size, prop) {
+      const char* const key  = unmap->unmap(unmap->handle, prop->key);
+      SerdNode*         pred = serd_new_uri(SERD_MEASURE_STRING(key));
+      write_atom(ctx,
+                 id,
+                 pred,
+                 prop->value.type,
+                 prop->value.size,
+                 LV2_ATOM_BODY(&prop->value));
+      serd_node_free(pred);
+    }
+    end_object(ctx, subject, predicate, id);
+    serd_node_free(id);
+  } else if (type == writer->forge.Sequence) {
+    const LV2_Atom_Sequence_Body* seq = (const LV2_Atom_Sequence_Body*)body;
+    SerdNode* id = serd_node_copy(serd_world_get_blank(writer->world));
+    start_object(ctx, subject, predicate, id, type_uri);
+    const SerdNode* p = writer->nodes.rdf_value;
+    ctx->sflags |= SERD_LIST_O;
+    LV2_ATOM_SEQUENCE_BODY_FOREACH (seq, size, ev) {
+      ctx->seq_unit = seq->unit;
+      list_append(ctx,
+                  &id,
+                  &p,
+                  sizeof(LV2_Atom_Event) + ev->body.size,
+                  writer->atom_Event,
+                  ev);
+    }
+    list_end(ctx, id, p);
+    end_object(ctx, subject, predicate, id);
+    serd_node_free(id);
+  } else {
+    const SerdNode* id = serd_world_get_blank(writer->world);
+    start_object(ctx, subject, predicate, id, type_uri);
+    const SerdNode* p = writer->nodes.rdf_value;
+    SerdNode*       o = serd_new_blob(body, size, NULL);
+    serd_sink_write(sink, ctx->sflags, id, p, o, NULL);
+    end_object(ctx, subject, predicate, id);
+    serd_node_free(o);
+  }
+
+  if (object) {
+    if (!subject && !predicate) {
+      subject   = serd_world_get_blank(writer->world);
+      predicate = writer->nodes.rdf_first;
+      serd_sink_write(sink,
+                      ctx->sflags | SERD_LIST_S | SERD_TERSE_S,
+                      subject,
+                      predicate,
+                      object,
+                      NULL);
+      serd_sink_write(sink,
+                      SERD_TERSE_S,
+                      subject,
+                      writer->nodes.rdf_rest,
+                      writer->nodes.rdf_nil,
+                      NULL);
+    } else {
+      serd_sink_write(sink, ctx->sflags, subject, predicate, object, NULL);
+    }
+  }
+
+  serd_node_free(object);
+
+  return 0;
+}
+
+int
+sratom_dump(SratomDumper* const     writer,
+            const SerdEnv* const    env,
+            const SerdSink* const   sink,
+            const SerdNode* const   subject,
+            const SerdNode* const   predicate,
+            const LV2_URID          type,
+            const uint32_t          size,
+            const void* const       body,
+            const SratomDumperFlags flags)
+{
+  StreamContext ctx = {writer,
+                       env,
+                       sink,
+                       flags,
+                       (flags & SRATOM_NAMED_SUBJECT) ? 0 : SERD_EMPTY_S,
+                       0};
+
+  return write_atom(&ctx, subject, predicate, type, size, body);
+}
+
+int
+sratom_dump_atom(SratomDumper* const     writer,
+                 const SerdEnv* const    env,
+                 const SerdSink* const   sink,
+                 const SerdNode* const   subject,
+                 const SerdNode* const   predicate,
+                 const LV2_Atom* const   atom,
+                 const SratomDumperFlags flags)
+{
+  return sratom_dump(writer,
+                     env,
+                     sink,
+                     subject,
+                     predicate,
+                     atom->type,
+                     atom->size,
+                     atom + 1,
+                     flags);
+}
+
+char*
+sratom_to_string(SratomDumper* const     writer,
+                 const SerdEnv* const    env,
+                 const LV2_Atom* const   atom,
+                 const SratomDumperFlags flags)
+{
+  SerdBuffer          buffer = {NULL, 0};
+  SerdByteSink* const out    = serd_byte_sink_new_buffer(&buffer);
+
+  SerdWriter* const ttl_writer =
+    serd_writer_new(writer->world,
+                    SERD_TURTLE,
+                    flags & SRATOM_TERSE ? SERD_WRITE_TERSE : 0,
+                    env,
+                    out);
+
+  const SerdSink* const sink = serd_writer_sink(ttl_writer);
+
+  sratom_dump_atom(writer, env, sink, NULL, NULL, atom, flags);
+  serd_writer_finish(ttl_writer);
+  serd_writer_free(ttl_writer);
+
+  return serd_buffer_sink_finish(&buffer);
+}
diff --git a/src/loader.c b/src/loader.c
new file mode 100644
index 0000000..46e7c51
--- /dev/null
+++ b/src/loader.c
@@ -0,0 +1,519 @@
+/*
+  Copyright 2012-2021 David Robillard <d@drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include "sratom/sratom.h"
+
+#include "lv2/atom/atom.h"
+#include "lv2/atom/forge.h"
+#include "lv2/midi/midi.h"
+#include "lv2/urid/urid.h"
+#include "serd/serd.h"
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define NS_RDF "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+#define NS_XSD "http://www.w3.org/2001/XMLSchema#"
+
+#define LOAD_ERROR(msg) \
+  serd_world_logf(loader->world, "sratom", SERD_LOG_LEVEL_ERROR, 0, NULL, msg);
+
+typedef enum { MODE_SUBJECT, MODE_BODY, MODE_SEQUENCE } ReadMode;
+
+struct SratomLoaderImpl {
+  LV2_URID_Map*  map;
+  LV2_Atom_Forge forge;
+  SerdWorld*     world;
+  LV2_URID       atom_frameTime;
+  LV2_URID       atom_beatTime;
+  LV2_URID       midi_MidiEvent;
+  struct {
+    const SerdNode* atom_beatTime;
+    const SerdNode* atom_childType;
+    const SerdNode* atom_frameTime;
+    const SerdNode* rdf_first;
+    const SerdNode* rdf_rest;
+    const SerdNode* rdf_type;
+    const SerdNode* rdf_value;
+    const SerdNode* xsd_base64Binary;
+  } nodes;
+};
+
+typedef struct {
+  SratomLoader*   loader;
+  const SerdNode* base_uri;
+  LV2_URID        seq_unit;
+} LoadContext;
+
+static void
+read_node(LoadContext*     ctx,
+          LV2_Atom_Forge*  forge,
+          const SerdModel* model,
+          const SerdNode*  node,
+          ReadMode         mode);
+
+SratomLoader*
+sratom_loader_new(SerdWorld* world, LV2_URID_Map* map)
+{
+  SratomLoader* sratom = (SratomLoader*)calloc(1, sizeof(SratomLoader));
+  if (!sratom) {
+    return NULL;
+  }
+
+  sratom->world          = world;
+  sratom->map            = map;
+  sratom->atom_frameTime = map->map(map->handle, LV2_ATOM__frameTime);
+  sratom->atom_beatTime  = map->map(map->handle, LV2_ATOM__beatTime);
+  sratom->midi_MidiEvent = map->map(map->handle, LV2_MIDI__MidiEvent);
+  lv2_atom_forge_init(&sratom->forge, map);
+
+#define MANAGE_URI(uri)                      \
+  serd_nodes_manage(serd_world_nodes(world), \
+                    serd_new_uri(SERD_STATIC_STRING(uri)))
+
+  sratom->nodes.atom_beatTime    = MANAGE_URI(LV2_ATOM__beatTime);
+  sratom->nodes.atom_childType   = MANAGE_URI(LV2_ATOM__childType);
+  sratom->nodes.atom_frameTime   = MANAGE_URI(LV2_ATOM__frameTime);
+  sratom->nodes.rdf_first        = MANAGE_URI(NS_RDF "first");
+  sratom->nodes.rdf_rest         = MANAGE_URI(NS_RDF "rest");
+  sratom->nodes.rdf_type         = MANAGE_URI(NS_RDF "type");
+  sratom->nodes.rdf_value        = MANAGE_URI(NS_RDF "value");
+  sratom->nodes.xsd_base64Binary = MANAGE_URI(NS_XSD "base64Binary");
+
+#undef INTERN_URI
+
+  return sratom;
+}
+
+void
+sratom_loader_free(SratomLoader* loader)
+{
+  free(loader);
+}
+
+static void
+read_list_value(LoadContext*     ctx,
+                LV2_Atom_Forge*  forge,
+                const SerdModel* model,
+                const SerdNode*  node,
+                ReadMode         mode)
+{
+  const SerdNode* fst =
+    serd_model_get(model, node, ctx->loader->nodes.rdf_first, NULL, NULL);
+  const SerdNode* rst =
+    serd_model_get(model, node, ctx->loader->nodes.rdf_rest, NULL, NULL);
+  if (fst && rst) {
+    read_node(ctx, forge, model, fst, mode);
+    read_list_value(ctx, forge, model, rst, mode);
+  }
+}
+
+static void
+read_resource(LoadContext*     ctx,
+              LV2_Atom_Forge*  forge,
+              const SerdModel* model,
+              const SerdNode*  node,
+              LV2_URID         otype)
+{
+  LV2_URID_Map* map = ctx->loader->map;
+  SerdRange*    r   = serd_model_range(model, node, NULL, NULL, NULL);
+  for (; !serd_range_empty(r); serd_range_next(r)) {
+    const SerdStatement* match = serd_range_front(r);
+    const SerdNode*      p     = serd_statement_predicate(match);
+    const SerdNode*      o     = serd_statement_object(match);
+    if (p) {
+      const char* p_uri  = serd_node_string(p);
+      uint32_t    p_urid = map->map(map->handle, p_uri);
+      if (!(serd_node_equals(p, ctx->loader->nodes.rdf_type) &&
+            serd_node_type(o) == SERD_URI &&
+            map->map(map->handle, serd_node_string(o)) == otype)) {
+        lv2_atom_forge_key(forge, p_urid);
+        read_node(ctx, forge, model, o, MODE_BODY);
+      }
+    }
+  }
+  serd_range_free(r);
+}
+
+static uint32_t
+atom_size(SratomLoader* loader, uint32_t type_urid)
+{
+  if (type_urid == loader->forge.Int) {
+    return sizeof(int32_t);
+  } else if (type_urid == loader->forge.Long) {
+    return sizeof(int64_t);
+  } else if (type_urid == loader->forge.Float) {
+    return sizeof(float);
+  } else if (type_urid == loader->forge.Double) {
+    return sizeof(double);
+  } else if (type_urid == loader->forge.Bool) {
+    return sizeof(int32_t);
+  } else if (type_urid == loader->forge.URID) {
+    return sizeof(uint32_t);
+  }
+  return 0;
+}
+
+static void
+read_uri(LoadContext* ctx, LV2_Atom_Forge* forge, const SerdNode* node)
+{
+  SratomLoader* const loader = ctx->loader;
+  LV2_URID_Map* const map    = loader->map;
+  const char* const   str    = serd_node_string(node);
+
+  if (!strcmp(str, NS_RDF "nil")) {
+    lv2_atom_forge_atom(forge, 0, 0);
+  } else if (!strncmp(str, "file://", 7)) {
+    const SerdURIView base_uri = serd_node_uri_view(ctx->base_uri);
+    const SerdURIView uri      = serd_parse_uri(str);
+    if (serd_uri_is_within(uri, base_uri)) {
+      SerdNode* const rel = serd_new_parsed_uri(serd_relative_uri(
+        serd_parse_uri(str), serd_node_uri_view(ctx->base_uri)));
+
+      char* path = serd_parse_file_uri(serd_node_string(rel), NULL);
+      lv2_atom_forge_path(forge, path, strlen(path));
+      serd_free(path);
+      serd_node_free(rel);
+    } else {
+      char* const path = serd_parse_file_uri(str, NULL);
+      lv2_atom_forge_path(forge, path, strlen(path));
+      serd_free(path);
+    }
+  } else {
+    lv2_atom_forge_urid(forge, map->map(map->handle, str));
+  }
+}
+
+static void
+read_typed_literal(SratomLoader* const   loader,
+                   LV2_Atom_Forge* const forge,
+                   const SerdNode* const node,
+                   const SerdNode* const datatype)
+{
+  const char* const str      = serd_node_string(node);
+  const size_t      len      = serd_node_length(node);
+  const char* const type_uri = serd_node_string(datatype);
+
+  if (!strcmp(type_uri, NS_XSD "int") || !strcmp(type_uri, NS_XSD "integer")) {
+    lv2_atom_forge_int(forge, strtol(str, NULL, 10));
+  } else if (!strcmp(type_uri, NS_XSD "long")) {
+    lv2_atom_forge_long(forge, strtol(str, NULL, 10));
+  } else if (!strcmp(type_uri, NS_XSD "float") ||
+             !strcmp(type_uri, NS_XSD "decimal")) {
+    lv2_atom_forge_float(forge, serd_get_float(node));
+  } else if (!strcmp(type_uri, NS_XSD "double")) {
+    lv2_atom_forge_double(forge, serd_get_double(node));
+  } else if (!strcmp(type_uri, NS_XSD "boolean")) {
+    lv2_atom_forge_bool(forge, serd_get_boolean(node));
+  } else if (!strcmp(type_uri, NS_XSD "base64Binary")) {
+    size_t size = 0;
+    void*  body = serd_base64_decode(str, len, &size);
+    lv2_atom_forge_atom(forge, size, forge->Chunk);
+    lv2_atom_forge_write(forge, body, size);
+    free(body);
+  } else if (!strcmp(type_uri, LV2_ATOM__Path)) {
+    lv2_atom_forge_path(forge, str, len);
+  } else if (!strcmp(type_uri, LV2_MIDI__MidiEvent)) {
+    lv2_atom_forge_atom(forge, len / 2, loader->midi_MidiEvent);
+    for (const char* s = str; s < str + len; s += 2) {
+      unsigned num;
+      sscanf(s, "%2X", &num);
+      const uint8_t c = num;
+      lv2_atom_forge_raw(forge, &c, 1);
+    }
+    lv2_atom_forge_pad(forge, len / 2);
+  } else {
+    lv2_atom_forge_literal(
+      forge, str, len, loader->map->map(loader->map->handle, type_uri), 0);
+  }
+}
+
+static void
+read_plain_literal(SratomLoader* const   loader,
+                   LV2_Atom_Forge* const forge,
+                   const SerdNode* const node,
+                   const SerdNode* const language)
+{
+  const char* const str      = serd_node_string(node);
+  const size_t      len      = serd_node_length(node);
+  const char*       lang_str = serd_node_string(language);
+  const char*       prefix   = "http://lexvo.org/id/iso639-3/";
+  const size_t      lang_len = strlen(prefix) + strlen(lang_str);
+  char* const       lang_uri = (char*)calloc(lang_len + 1, 1);
+
+  snprintf(lang_uri, lang_len + 1, "%s%s", prefix, lang_str);
+
+  lv2_atom_forge_literal(
+    forge, str, len, 0, loader->map->map(loader->map->handle, lang_uri));
+
+  free(lang_uri);
+}
+
+static void
+read_literal(SratomLoader* loader, LV2_Atom_Forge* forge, const SerdNode* node)
+{
+  assert(serd_node_type(node) == SERD_LITERAL);
+
+  const SerdNode* const datatype = serd_node_datatype(node);
+  const SerdNode* const language = serd_node_language(node);
+  if (datatype) {
+    read_typed_literal(loader, forge, node, datatype);
+  } else if (language) {
+    read_plain_literal(loader, forge, node, language);
+  } else {
+    lv2_atom_forge_string(
+      forge, serd_node_string(node), serd_node_length(node));
+  }
+}
+
+static void
+read_object(LoadContext*     ctx,
+            LV2_Atom_Forge*  forge,
+            const SerdModel* model,
+            const SerdNode*  node,
+            ReadMode         mode)
+{
+  SratomLoader* const loader = ctx->loader;
+  LV2_URID_Map* const map    = loader->map;
+  const char* const   str    = serd_node_string(node);
+
+  const SerdNode* const type =
+    serd_model_get(model, node, loader->nodes.rdf_type, NULL, NULL);
+
+  const SerdNode* const value =
+    serd_model_get(model, node, loader->nodes.rdf_value, NULL, NULL);
+
+  const char* type_uri  = NULL;
+  uint32_t    type_urid = 0;
+  if (type) {
+    type_uri  = serd_node_string(type);
+    type_urid = map->map(map->handle, type_uri);
+  }
+
+  LV2_Atom_Forge_Frame frame = {0, 0};
+  if (mode == MODE_SEQUENCE) {
+    LV2_URID        seq_unit = 0u;
+    const SerdNode* time     = NULL;
+
+    if ((time = serd_model_get(
+           model, node, loader->nodes.atom_frameTime, NULL, NULL))) {
+      lv2_atom_forge_frame_time(forge, time ? serd_get_integer(time) : 0);
+      seq_unit = loader->atom_frameTime;
+
+    } else if ((time = serd_model_get(
+                  model, node, loader->nodes.atom_beatTime, NULL, NULL))) {
+      lv2_atom_forge_beat_time(forge, serd_get_double(time));
+      seq_unit = loader->atom_beatTime;
+    }
+
+    read_node(ctx, forge, model, value, MODE_BODY);
+    ctx->seq_unit = seq_unit;
+
+  } else if (type_urid == loader->forge.Tuple) {
+    lv2_atom_forge_tuple(forge, &frame);
+    read_list_value(ctx, forge, model, value, MODE_BODY);
+
+  } else if (type_urid == loader->forge.Sequence) {
+    const LV2_Atom_Forge_Ref ref =
+      lv2_atom_forge_sequence_head(forge, &frame, 0);
+    ctx->seq_unit = 0;
+    read_list_value(ctx, forge, model, value, MODE_SEQUENCE);
+
+    LV2_Atom_Sequence* seq =
+      (LV2_Atom_Sequence*)lv2_atom_forge_deref(forge, ref);
+    seq->body.unit =
+      ((ctx->seq_unit == loader->atom_frameTime) ? 0 : ctx->seq_unit);
+
+  } else if (type_urid == loader->forge.Vector) {
+    const SerdNode* child_type_node =
+      serd_model_get(model, node, loader->nodes.atom_childType, NULL, NULL);
+    uint32_t child_type =
+      map->map(map->handle, serd_node_string(child_type_node));
+    uint32_t child_size = atom_size(loader, child_type);
+    if (child_size > 0) {
+      LV2_Atom_Forge_Ref ref =
+        lv2_atom_forge_vector_head(forge, &frame, child_size, child_type);
+      read_list_value(ctx, forge, model, value, MODE_BODY);
+      lv2_atom_forge_pop(forge, &frame);
+      frame.ref = 0;
+      lv2_atom_forge_pad(forge, lv2_atom_forge_deref(forge, ref)->size);
+    }
+
+  } else if (value && serd_node_equals(serd_node_datatype(value),
+                                       loader->nodes.xsd_base64Binary)) {
+    const char*  vstr = serd_node_string(value);
+    const size_t vlen = serd_node_length(value);
+    size_t       size = 0;
+    void*        body = serd_base64_decode(vstr, vlen, &size);
+    lv2_atom_forge_atom(forge, size, type_urid);
+    lv2_atom_forge_write(forge, body, size);
+    free(body);
+
+  } else if (serd_node_type(node) == SERD_URI) {
+    const LV2_URID urid = map->map(map->handle, str);
+    if (serd_model_count(model, node, NULL, NULL, NULL)) {
+      lv2_atom_forge_object(forge, &frame, urid, type_urid);
+      read_resource(ctx, forge, model, node, type_urid);
+    } else {
+      read_uri(ctx, forge, node);
+    }
+
+  } else {
+    lv2_atom_forge_object(forge, &frame, 0, type_urid);
+    read_resource(ctx, forge, model, node, type_urid);
+  }
+
+  if (frame.ref) {
+    lv2_atom_forge_pop(forge, &frame);
+  }
+}
+
+static void
+read_node(LoadContext*     ctx,
+          LV2_Atom_Forge*  forge,
+          const SerdModel* model,
+          const SerdNode*  node,
+          ReadMode         mode)
+{
+  if (serd_node_type(node) == SERD_LITERAL) {
+    read_literal(ctx->loader, forge, node);
+  } else if (serd_node_type(node) == SERD_URI && mode != MODE_SUBJECT) {
+    read_uri(ctx, forge, node);
+  } else {
+    read_object(ctx, forge, model, node, mode);
+  }
+}
+
+int
+sratom_load(SratomLoader*    loader,
+            const SerdNode*  base_uri,
+            LV2_Atom_Forge*  forge,
+            const SerdModel* model,
+            const SerdNode*  node)
+{
+  LoadContext ctx = {loader, base_uri, 0};
+  read_node(&ctx, forge, model, node, MODE_SUBJECT);
+  return 0;
+}
+
+static SerdModel*
+model_from_string(SratomLoader* loader, SerdEnv* env, const char* str)
+{
+  SerdModel* const model    = serd_model_new(loader->world, SERD_INDEX_SPO);
+  SerdSink* const  inserter = serd_inserter_new(model, env, NULL);
+
+  SerdNode* const       name   = serd_new_string(SERD_STATIC_STRING("string"));
+  SerdByteSource* const source = serd_byte_source_new_string(str, name);
+  SerdReader* const     reader = serd_reader_new(
+    loader->world, SERD_TURTLE, SERD_READ_LAX, env, inserter, 4096);
+
+  serd_reader_start(reader, source);
+
+  const SerdStatus st = serd_reader_read_document(reader);
+
+  serd_reader_free(reader);
+  serd_byte_source_free(source);
+  serd_node_free(name);
+  serd_sink_free(inserter);
+
+  if (st) {
+    serd_model_free(model);
+    return NULL;
+  }
+
+  return model;
+}
+
+LV2_Atom*
+sratom_from_string(SratomLoader* const loader,
+                   SerdEnv* const      env,
+                   const char* const   str)
+{
+  SerdModel* model = model_from_string(loader, env, str);
+  if (!model || serd_model_empty(model)) {
+    LOAD_ERROR("Failed to read string into model");
+    return NULL;
+  }
+
+  const SerdNode*      node  = NULL;
+  SerdIter*            begin = serd_model_begin(model);
+  const SerdStatement* s     = serd_iter_get(begin);
+  if (serd_model_size(model) == 2 &&
+      serd_node_type(serd_statement_subject(s)) == SERD_BLANK &&
+      serd_node_equals(serd_statement_predicate(s), loader->nodes.rdf_first)) {
+    // Special single-element list syntax for literals
+    node = serd_statement_object(s);
+  } else {
+    node = serd_statement_subject(s);
+  }
+
+  if (!node) {
+    LOAD_ERROR("Failed to find a node to parse");
+    return NULL;
+  }
+
+  LV2_Atom* atom =
+    sratom_from_model(loader, serd_env_base_uri(env), model, node);
+
+  serd_iter_free(begin);
+  serd_model_free(model);
+  return atom;
+}
+
+static LV2_Atom_Forge_Ref
+sratom_forge_sink(LV2_Atom_Forge_Sink_Handle handle,
+                  const void*                buf,
+                  uint32_t                   size)
+{
+  SerdBuffer*              chunk = (SerdBuffer*)handle;
+  const LV2_Atom_Forge_Ref ref   = chunk->len + 1;
+  serd_buffer_sink(buf, 1, size, chunk);
+  return ref;
+}
+
+static LV2_Atom*
+sratom_forge_deref(LV2_Atom_Forge_Sink_Handle handle, LV2_Atom_Forge_Ref ref)
+{
+  SerdBuffer* chunk = (SerdBuffer*)handle;
+  return (LV2_Atom*)((char*)chunk->buf + ref - 1);
+}
+
+LV2_Atom*
+sratom_from_model(SratomLoader*    loader,
+                  const SerdNode*  base_uri,
+                  const SerdModel* model,
+                  const SerdNode*  subject)
+{
+  if (!subject) {
+    return NULL;
+  }
+
+  SerdBuffer out = {NULL, 0};
+  lv2_atom_forge_set_sink(
+    &loader->forge, sratom_forge_sink, sratom_forge_deref, &out);
+
+  int st = sratom_load(loader, base_uri, &loader->forge, model, subject);
+  if (st) {
+    sratom_free(out.buf);
+    out.buf = NULL;
+  }
+
+  return (LV2_Atom*)out.buf;
+}
diff --git a/src/sratom.c b/src/sratom.c
deleted file mode 100644
index 692257d..0000000
--- a/src/sratom.c
+++ /dev/null
@@ -1,924 +0,0 @@
-/*
-  Copyright 2012-2021 David Robillard <d@drobilla.net>
-
-  Permission to use, copy, modify, and/or distribute this software for any
-  purpose with or without fee is hereby granted, provided that the above
-  copyright notice and this permission notice appear in all copies.
-
-  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-
-#include "sratom/sratom.h"
-
-#include "lv2/atom/atom.h"
-#include "lv2/atom/forge.h"
-#include "lv2/atom/util.h"
-#include "lv2/midi/midi.h"
-#include "lv2/urid/urid.h"
-
-#include <assert.h>
-#include <ctype.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#define NS_RDF (const uint8_t*)"http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-#define NS_XSD (const uint8_t*)"http://www.w3.org/2001/XMLSchema#"
-
-#define USTR(str) ((const uint8_t*)(str))
-
-static const SerdStyle style =
-  (SerdStyle)(SERD_STYLE_ABBREVIATED | SERD_STYLE_RESOLVED | SERD_STYLE_CURIED);
-
-typedef enum { MODE_SUBJECT, MODE_BODY, MODE_SEQUENCE } ReadMode;
-
-struct SratomImpl {
-  LV2_URID_Map*     map;
-  LV2_Atom_Forge    forge;
-  SerdEnv*          env;
-  SerdNode          base_uri;
-  SerdURI           base;
-  SerdStatementSink write_statement;
-  SerdEndSink       end_anon;
-  void*             handle;
-  LV2_URID          atom_Event;
-  LV2_URID          atom_frameTime;
-  LV2_URID          atom_beatTime;
-  LV2_URID          midi_MidiEvent;
-  unsigned          next_id;
-  SratomObjectMode  object_mode;
-  uint32_t          seq_unit;
-  struct {
-    SordNode* atom_childType;
-    SordNode* atom_frameTime;
-    SordNode* atom_beatTime;
-    SordNode* rdf_first;
-    SordNode* rdf_rest;
-    SordNode* rdf_type;
-    SordNode* rdf_value;
-    SordNode* xsd_base64Binary;
-  } nodes;
-
-  bool pretty_numbers;
-};
-
-static void
-read_node(Sratom*         sratom,
-          LV2_Atom_Forge* forge,
-          SordWorld*      world,
-          SordModel*      model,
-          const SordNode* node,
-          ReadMode        mode);
-
-Sratom*
-sratom_new(LV2_URID_Map* map)
-{
-  Sratom* sratom = (Sratom*)calloc(1, sizeof(Sratom));
-  if (sratom) {
-    sratom->map            = map;
-    sratom->atom_Event     = map->map(map->handle, LV2_ATOM__Event);
-    sratom->atom_frameTime = map->map(map->handle, LV2_ATOM__frameTime);
-    sratom->atom_beatTime  = map->map(map->handle, LV2_ATOM__beatTime);
-    sratom->midi_MidiEvent = map->map(map->handle, LV2_MIDI__MidiEvent);
-    sratom->object_mode    = SRATOM_OBJECT_MODE_BLANK;
-    lv2_atom_forge_init(&sratom->forge, map);
-  }
-  return sratom;
-}
-
-void
-sratom_free(Sratom* sratom)
-{
-  if (sratom) {
-    serd_node_free(&sratom->base_uri);
-    free(sratom);
-  }
-}
-
-void
-sratom_set_env(Sratom* sratom, SerdEnv* env)
-{
-  sratom->env = env;
-}
-
-void
-sratom_set_sink(Sratom*           sratom,
-                const char*       base_uri,
-                SerdStatementSink sink,
-                SerdEndSink       end_sink,
-                void*             handle)
-{
-  if (base_uri) {
-    serd_node_free(&sratom->base_uri);
-    sratom->base_uri =
-      serd_node_new_uri_from_string(USTR(base_uri), NULL, NULL);
-    serd_uri_parse(sratom->base_uri.buf, &sratom->base);
-  }
-  sratom->write_statement = sink;
-  sratom->end_anon        = end_sink;
-  sratom->handle          = handle;
-}
-
-void
-sratom_set_pretty_numbers(Sratom* sratom, bool pretty_numbers)
-{
-  sratom->pretty_numbers = pretty_numbers;
-}
-
-void
-sratom_set_object_mode(Sratom* sratom, SratomObjectMode object_mode)
-{
-  sratom->object_mode = object_mode;
-}
-
-static void
-gensym(SerdNode* out, char c, unsigned num)
-{
-  out->n_bytes = out->n_chars = snprintf((char*)out->buf, 12, "%c%u", c, num);
-}
-
-static void
-list_append(Sratom*         sratom,
-            LV2_URID_Unmap* unmap,
-            unsigned*       flags,
-            SerdNode*       s,
-            SerdNode*       p,
-            SerdNode*       node,
-            uint32_t        size,
-            uint32_t        type,
-            const void*     body)
-{
-  // Generate a list node
-  gensym(node, 'l', sratom->next_id);
-  sratom->write_statement(sratom->handle, *flags, NULL, s, p, node, NULL, NULL);
-
-  // _:node rdf:first value
-  *flags = SERD_LIST_CONT;
-  *p     = serd_node_from_string(SERD_URI, NS_RDF "first");
-  sratom_write(sratom, unmap, *flags, node, p, type, size, body);
-
-  // Set subject to node and predicate to rdf:rest for next time
-  gensym(node, 'l', ++sratom->next_id);
-  *s = *node;
-  *p = serd_node_from_string(SERD_URI, NS_RDF "rest");
-}
-
-static void
-list_end(SerdStatementSink sink,
-         void*             handle,
-         const unsigned    flags,
-         SerdNode*         s,
-         SerdNode*         p)
-{
-  // _:node rdf:rest rdf:nil
-  const SerdNode nil = serd_node_from_string(SERD_URI, NS_RDF "nil");
-  sink(handle, flags, NULL, s, p, &nil, NULL, NULL);
-}
-
-static void
-start_object(Sratom*         sratom,
-             uint32_t*       flags,
-             const SerdNode* subject,
-             const SerdNode* predicate,
-             const SerdNode* node,
-             const char*     type)
-{
-  if (subject && predicate) {
-    sratom->write_statement(sratom->handle,
-                            *flags | SERD_ANON_O_BEGIN,
-                            NULL,
-                            subject,
-                            predicate,
-                            node,
-                            NULL,
-                            NULL);
-    // Start abbreviating object properties
-    *flags |= SERD_ANON_CONT;
-
-    // Object is in a list, stop list abbreviating if necessary
-    *flags &= ~SERD_LIST_CONT;
-  }
-
-  if (type) {
-    SerdNode p = serd_node_from_string(SERD_URI, NS_RDF "type");
-    SerdNode o = serd_node_from_string(SERD_URI, USTR(type));
-    sratom->write_statement(
-      sratom->handle, *flags, NULL, node, &p, &o, NULL, NULL);
-  }
-}
-
-static bool
-path_is_absolute(const char* path)
-{
-  return (path[0] == '/' || (isalpha(path[0]) && path[1] == ':' &&
-                             (path[2] == '/' || path[2] == '\\')));
-}
-
-static SerdNode
-number_type(const Sratom* sratom, const uint8_t* type)
-{
-  if (sratom->pretty_numbers &&
-      (!strcmp((const char*)type, (const char*)NS_XSD "int") ||
-       !strcmp((const char*)type, (const char*)NS_XSD "long"))) {
-    return serd_node_from_string(SERD_URI, NS_XSD "integer");
-  }
-
-  if (sratom->pretty_numbers &&
-      (!strcmp((const char*)type, (const char*)NS_XSD "float") ||
-       !strcmp((const char*)type, (const char*)NS_XSD "double"))) {
-    return serd_node_from_string(SERD_URI, NS_XSD "decimal");
-  }
-
-  return serd_node_from_string(SERD_URI, type);
-}
-
-int
-sratom_write(Sratom*         sratom,
-             LV2_URID_Unmap* unmap,
-             uint32_t        flags,
-             const SerdNode* subject,
-             const SerdNode* predicate,
-             uint32_t        type_urid,
-             uint32_t        size,
-             const void*     body)
-{
-  const char* const type        = unmap->unmap(unmap->handle, type_urid);
-  uint8_t           idbuf[12]   = "b0000000000";
-  SerdNode          id          = serd_node_from_string(SERD_BLANK, idbuf);
-  uint8_t           nodebuf[12] = "b0000000000";
-  SerdNode          node        = serd_node_from_string(SERD_BLANK, nodebuf);
-  SerdNode          object      = SERD_NODE_NULL;
-  SerdNode          datatype    = SERD_NODE_NULL;
-  SerdNode          language    = SERD_NODE_NULL;
-  bool              new_node    = false;
-  if (type_urid == 0 && size == 0) {
-    object = serd_node_from_string(SERD_URI, USTR(NS_RDF "nil"));
-  } else if (type_urid == sratom->forge.String) {
-    object = serd_node_from_string(SERD_LITERAL, (const uint8_t*)body);
-  } else if (type_urid == sratom->forge.Chunk) {
-    datatype = serd_node_from_string(SERD_URI, NS_XSD "base64Binary");
-    object   = serd_node_new_blob(body, size, true);
-    new_node = true;
-  } else if (type_urid == sratom->forge.Literal) {
-    const LV2_Atom_Literal_Body* lit = (const LV2_Atom_Literal_Body*)body;
-    const uint8_t*               str = USTR(lit + 1);
-
-    object = serd_node_from_string(SERD_LITERAL, str);
-    if (lit->datatype) {
-      datatype = serd_node_from_string(
-        SERD_URI, USTR(unmap->unmap(unmap->handle, lit->datatype)));
-    } else if (lit->lang) {
-      const char*  lang       = unmap->unmap(unmap->handle, lit->lang);
-      const char*  prefix     = "http://lexvo.org/id/iso639-3/";
-      const size_t prefix_len = strlen(prefix);
-      if (lang && !strncmp(lang, prefix, prefix_len)) {
-        language = serd_node_from_string(SERD_LITERAL, USTR(lang + prefix_len));
-      } else {
-        fprintf(stderr, "Unknown language URID %u\n", lit->lang);
-      }
-    }
-  } else if (type_urid == sratom->forge.URID) {
-    const uint32_t urid = *(const uint32_t*)body;
-    const uint8_t* str  = USTR(unmap->unmap(unmap->handle, urid));
-
-    object = serd_node_from_string(SERD_URI, str);
-  } else if (type_urid == sratom->forge.Path) {
-    const uint8_t* str = USTR(body);
-    if (path_is_absolute((const char*)str)) {
-      new_node = true;
-      object   = serd_node_new_file_uri(str, NULL, NULL, true);
-    } else {
-      if (!sratom->base_uri.buf ||
-          strncmp((const char*)sratom->base_uri.buf, "file://", 7)) {
-        fprintf(stderr, "warning: Relative path but base is not a file URI.\n");
-        fprintf(stderr, "warning: Writing ambiguous atom:Path literal.\n");
-        object   = serd_node_from_string(SERD_LITERAL, str);
-        datatype = serd_node_from_string(SERD_URI, USTR(LV2_ATOM__Path));
-      } else {
-        new_node     = true;
-        SerdNode rel = serd_node_new_file_uri(str, NULL, NULL, true);
-        object       = serd_node_new_uri_from_node(&rel, &sratom->base, NULL);
-        serd_node_free(&rel);
-      }
-    }
-  } else if (type_urid == sratom->forge.URI) {
-    object = serd_node_from_string(SERD_URI, USTR(body));
-  } else if (type_urid == sratom->forge.Int) {
-    new_node = true;
-    object   = serd_node_new_integer(*(const int32_t*)body);
-    datatype = number_type(sratom, NS_XSD "int");
-  } else if (type_urid == sratom->forge.Long) {
-    new_node = true;
-    object   = serd_node_new_integer(*(const int64_t*)body);
-    datatype = number_type(sratom, NS_XSD "long");
-  } else if (type_urid == sratom->forge.Float) {
-    new_node = true;
-    object   = serd_node_new_decimal(*(const float*)body, 8);
-    datatype = number_type(sratom, NS_XSD "float");
-  } else if (type_urid == sratom->forge.Double) {
-    new_node = true;
-    object   = serd_node_new_decimal(*(const double*)body, 16);
-    datatype = number_type(sratom, NS_XSD "double");
-  } else if (type_urid == sratom->forge.Bool) {
-    const int32_t val = *(const int32_t*)body;
-
-    datatype = serd_node_from_string(SERD_URI, NS_XSD "boolean");
-    object = serd_node_from_string(SERD_LITERAL, USTR(val ? "true" : "false"));
-  } else if (type_urid == sratom->midi_MidiEvent) {
-    new_node = true;
-    datatype = serd_node_from_string(SERD_URI, USTR(LV2_MIDI__MidiEvent));
-
-    uint8_t* str = (uint8_t*)calloc(size * 2 + 1, 1);
-    for (uint32_t i = 0; i < size; ++i) {
-      snprintf((char*)str + (2 * i),
-               size * 2 + 1,
-               "%02X",
-               (unsigned)*((const uint8_t*)body + i));
-    }
-    object = serd_node_from_string(SERD_LITERAL, USTR(str));
-  } else if (type_urid == sratom->atom_Event) {
-    const LV2_Atom_Event* ev = (const LV2_Atom_Event*)body;
-    gensym(&id, 'e', sratom->next_id++);
-    start_object(sratom, &flags, subject, predicate, &id, NULL);
-    SerdNode time;
-    SerdNode p;
-    if (sratom->seq_unit == sratom->atom_beatTime) {
-      time     = serd_node_new_decimal(ev->time.beats, 16);
-      p        = serd_node_from_string(SERD_URI, USTR(LV2_ATOM__beatTime));
-      datatype = number_type(sratom, NS_XSD "double");
-    } else {
-      time     = serd_node_new_integer(ev->time.frames);
-      p        = serd_node_from_string(SERD_URI, USTR(LV2_ATOM__frameTime));
-      datatype = number_type(sratom, NS_XSD "long");
-    }
-    sratom->write_statement(sratom->handle,
-                            SERD_ANON_CONT,
-                            NULL,
-                            &id,
-                            &p,
-                            &time,
-                            &datatype,
-                            &language);
-    serd_node_free(&time);
-
-    p = serd_node_from_string(SERD_URI, NS_RDF "value");
-    sratom_write(sratom,
-                 unmap,
-                 SERD_ANON_CONT,
-                 &id,
-                 &p,
-                 ev->body.type,
-                 ev->body.size,
-                 LV2_ATOM_BODY(&ev->body));
-    if (sratom->end_anon) {
-      sratom->end_anon(sratom->handle, &id);
-    }
-  } else if (type_urid == sratom->forge.Tuple) {
-    gensym(&id, 't', sratom->next_id++);
-    start_object(sratom, &flags, subject, predicate, &id, type);
-    SerdNode p = serd_node_from_string(SERD_URI, NS_RDF "value");
-    flags |= SERD_LIST_O_BEGIN;
-    LV2_ATOM_TUPLE_BODY_FOREACH (body, size, i) {
-      list_append(sratom,
-                  unmap,
-                  &flags,
-                  &id,
-                  &p,
-                  &node,
-                  i->size,
-                  i->type,
-                  LV2_ATOM_BODY(i));
-    }
-    list_end(sratom->write_statement, sratom->handle, flags, &id, &p);
-    if (sratom->end_anon) {
-      sratom->end_anon(sratom->handle, &id);
-    }
-  } else if (type_urid == sratom->forge.Vector) {
-    const LV2_Atom_Vector_Body* vec = (const LV2_Atom_Vector_Body*)body;
-    gensym(&id, 'v', sratom->next_id++);
-    start_object(sratom, &flags, subject, predicate, &id, type);
-    SerdNode p =
-      serd_node_from_string(SERD_URI, (const uint8_t*)LV2_ATOM__childType);
-    SerdNode child_type = serd_node_from_string(
-      SERD_URI, (const uint8_t*)unmap->unmap(unmap->handle, vec->child_type));
-    sratom->write_statement(
-      sratom->handle, flags, NULL, &id, &p, &child_type, NULL, NULL);
-    p = serd_node_from_string(SERD_URI, NS_RDF "value");
-    flags |= SERD_LIST_O_BEGIN;
-    for (const char* i = (const char*)(vec + 1); i < (const char*)vec + size;
-         i += vec->child_size) {
-      list_append(sratom,
-                  unmap,
-                  &flags,
-                  &id,
-                  &p,
-                  &node,
-                  vec->child_size,
-                  vec->child_type,
-                  i);
-    }
-    list_end(sratom->write_statement, sratom->handle, flags, &id, &p);
-    if (sratom->end_anon) {
-      sratom->end_anon(sratom->handle, &id);
-    }
-  } else if (lv2_atom_forge_is_object_type(&sratom->forge, type_urid)) {
-    const LV2_Atom_Object_Body* obj   = (const LV2_Atom_Object_Body*)body;
-    const char*                 otype = unmap->unmap(unmap->handle, obj->otype);
-
-    if (lv2_atom_forge_is_blank(&sratom->forge, type_urid, obj)) {
-      gensym(&id, 'b', sratom->next_id++);
-      start_object(sratom, &flags, subject, predicate, &id, otype);
-    } else {
-      id = serd_node_from_string(
-        SERD_URI, (const uint8_t*)unmap->unmap(unmap->handle, obj->id));
-      flags = 0;
-      start_object(sratom, &flags, NULL, NULL, &id, otype);
-    }
-    LV2_ATOM_OBJECT_BODY_FOREACH (obj, size, prop) {
-      const char* const key  = unmap->unmap(unmap->handle, prop->key);
-      SerdNode          pred = serd_node_from_string(SERD_URI, USTR(key));
-      sratom_write(sratom,
-                   unmap,
-                   flags,
-                   &id,
-                   &pred,
-                   prop->value.type,
-                   prop->value.size,
-                   LV2_ATOM_BODY(&prop->value));
-    }
-    if (sratom->end_anon && (flags & SERD_ANON_CONT)) {
-      sratom->end_anon(sratom->handle, &id);
-    }
-  } else if (type_urid == sratom->forge.Sequence) {
-    const LV2_Atom_Sequence_Body* seq = (const LV2_Atom_Sequence_Body*)body;
-    gensym(&id, 'v', sratom->next_id++);
-    start_object(sratom, &flags, subject, predicate, &id, type);
-    SerdNode p = serd_node_from_string(SERD_URI, NS_RDF "value");
-    flags |= SERD_LIST_O_BEGIN;
-    LV2_ATOM_SEQUENCE_BODY_FOREACH (seq, size, ev) {
-      sratom->seq_unit = seq->unit;
-      list_append(sratom,
-                  unmap,
-                  &flags,
-                  &id,
-                  &p,
-                  &node,
-                  sizeof(LV2_Atom_Event) + ev->body.size,
-                  sratom->atom_Event,
-                  ev);
-    }
-    list_end(sratom->write_statement, sratom->handle, flags, &id, &p);
-    if (sratom->end_anon && subject && predicate) {
-      sratom->end_anon(sratom->handle, &id);
-    }
-  } else {
-    gensym(&id, 'b', sratom->next_id++);
-    start_object(sratom, &flags, subject, predicate, &id, type);
-    SerdNode p = serd_node_from_string(SERD_URI, NS_RDF "value");
-    SerdNode o = serd_node_new_blob(body, size, true);
-    datatype   = serd_node_from_string(SERD_URI, NS_XSD "base64Binary");
-    sratom->write_statement(
-      sratom->handle, flags, NULL, &id, &p, &o, &datatype, NULL);
-    if (sratom->end_anon && subject && predicate) {
-      sratom->end_anon(sratom->handle, &id);
-    }
-    serd_node_free(&o);
-  }
-
-  if (object.buf) {
-    SerdNode def_s = serd_node_from_string(SERD_BLANK, USTR("atom"));
-    SerdNode def_p = serd_node_from_string(SERD_URI, USTR(NS_RDF "value"));
-
-    if (!subject) {
-      subject = &def_s;
-    }
-
-    if (!predicate) {
-      predicate = &def_p;
-    }
-
-    sratom->write_statement(sratom->handle,
-                            flags,
-                            NULL,
-                            subject,
-                            predicate,
-                            &object,
-                            &datatype,
-                            &language);
-  }
-
-  if (new_node) {
-    serd_node_free(&object);
-  }
-
-  return 0;
-}
-
-char*
-sratom_to_turtle(Sratom*         sratom,
-                 LV2_URID_Unmap* unmap,
-                 const char*     base_uri,
-                 const SerdNode* subject,
-                 const SerdNode* predicate,
-                 uint32_t        type,
-                 uint32_t        size,
-                 const void*     body)
-{
-  SerdURI  buri = SERD_URI_NULL;
-  SerdNode base =
-    serd_node_new_uri_from_string(USTR(base_uri), &sratom->base, &buri);
-  SerdEnv*    env = sratom->env ? sratom->env : serd_env_new(NULL);
-  SerdChunk   str = {NULL, 0};
-  SerdWriter* writer =
-    serd_writer_new(SERD_TURTLE, style, env, &buri, serd_chunk_sink, &str);
-
-  serd_env_set_base_uri(env, &base);
-  sratom_set_sink(sratom,
-                  base_uri,
-                  (SerdStatementSink)serd_writer_write_statement,
-                  (SerdEndSink)serd_writer_end_anon,
-                  writer);
-  sratom_write(
-    sratom, unmap, SERD_EMPTY_S, subject, predicate, type, size, body);
-  serd_writer_finish(writer);
-
-  serd_writer_free(writer);
-  if (!sratom->env) {
-    serd_env_free(env);
-  }
-
-  serd_node_free(&base);
-  return (char*)serd_chunk_sink_finish(&str);
-}
-
-static void
-read_list_value(Sratom*         sratom,
-                LV2_Atom_Forge* forge,
-                SordWorld*      world,
-                SordModel*      model,
-                const SordNode* node,
-                ReadMode        mode)
-{
-  SordNode* fst = sord_get(model, node, sratom->nodes.rdf_first, NULL, NULL);
-  SordNode* rst = sord_get(model, node, sratom->nodes.rdf_rest, NULL, NULL);
-  if (fst && rst) {
-    read_node(sratom, forge, world, model, fst, mode);
-    read_list_value(sratom, forge, world, model, rst, mode);
-  }
-
-  sord_node_free(world, rst);
-  sord_node_free(world, fst);
-}
-
-static void
-read_resource(Sratom*         sratom,
-              LV2_Atom_Forge* forge,
-              SordWorld*      world,
-              SordModel*      model,
-              const SordNode* node,
-              LV2_URID        otype)
-{
-  LV2_URID_Map* map = sratom->map;
-  SordQuad      q   = {node, NULL, NULL, NULL};
-  SordIter*     i   = sord_find(model, q);
-  SordQuad      match;
-  for (; !sord_iter_end(i); sord_iter_next(i)) {
-    sord_iter_get(i, match);
-    const SordNode* p      = match[SORD_PREDICATE];
-    const SordNode* o      = match[SORD_OBJECT];
-    const char*     p_uri  = (const char*)sord_node_get_string(p);
-    uint32_t        p_urid = map->map(map->handle, p_uri);
-    if (!(sord_node_equals(p, sratom->nodes.rdf_type) &&
-          sord_node_get_type(o) == SORD_URI &&
-          map->map(map->handle, (const char*)sord_node_get_string(o)) ==
-            otype)) {
-      lv2_atom_forge_key(forge, p_urid);
-      read_node(sratom, forge, world, model, o, MODE_BODY);
-    }
-  }
-  sord_iter_free(i);
-}
-
-static uint32_t
-atom_size(Sratom* sratom, uint32_t type_urid)
-{
-  if (type_urid == sratom->forge.Int || type_urid == sratom->forge.Bool) {
-    return sizeof(int32_t);
-  }
-
-  if (type_urid == sratom->forge.Long) {
-    return sizeof(int64_t);
-  }
-
-  if (type_urid == sratom->forge.Float) {
-    return sizeof(float);
-  }
-
-  if (type_urid == sratom->forge.Double) {
-    return sizeof(double);
-  }
-
-  if (type_urid == sratom->forge.URID) {
-    return sizeof(uint32_t);
-  }
-
-  return 0;
-}
-
-static void
-read_literal(Sratom* sratom, LV2_Atom_Forge* forge, const SordNode* node)
-{
-  assert(sord_node_get_type(node) == SORD_LITERAL);
-
-  size_t      len      = 0;
-  const char* str      = (const char*)sord_node_get_string_counted(node, &len);
-  SordNode*   datatype = sord_node_get_datatype(node);
-  const char* language = sord_node_get_language(node);
-  if (datatype) {
-    const char* type_uri = (const char*)sord_node_get_string(datatype);
-    if (!strcmp(type_uri, (const char*)NS_XSD "int") ||
-        !strcmp(type_uri, (const char*)NS_XSD "integer")) {
-      lv2_atom_forge_int(forge, strtol(str, NULL, 10));
-    } else if (!strcmp(type_uri, (const char*)NS_XSD "long")) {
-      lv2_atom_forge_long(forge, strtol(str, NULL, 10));
-    } else if (!strcmp(type_uri, (const char*)NS_XSD "float") ||
-               !strcmp(type_uri, (const char*)NS_XSD "decimal")) {
-      lv2_atom_forge_float(forge, (float)serd_strtod(str, NULL));
-    } else if (!strcmp(type_uri, (const char*)NS_XSD "double")) {
-      lv2_atom_forge_double(forge, serd_strtod(str, NULL));
-    } else if (!strcmp(type_uri, (const char*)NS_XSD "boolean")) {
-      lv2_atom_forge_bool(forge, !strcmp(str, "true"));
-    } else if (!strcmp(type_uri, (const char*)NS_XSD "base64Binary")) {
-      size_t size = 0;
-      void*  body = serd_base64_decode(USTR(str), len, &size);
-      lv2_atom_forge_atom(forge, size, forge->Chunk);
-      lv2_atom_forge_write(forge, body, size);
-      free(body);
-    } else if (!strcmp(type_uri, LV2_ATOM__Path)) {
-      lv2_atom_forge_path(forge, str, len);
-    } else if (!strcmp(type_uri, LV2_MIDI__MidiEvent)) {
-      lv2_atom_forge_atom(forge, len / 2, sratom->midi_MidiEvent);
-      for (const char* s = str; s < str + len; s += 2) {
-        unsigned num = 0u;
-        sscanf(s, "%2X", &num);
-        const uint8_t c = num;
-        lv2_atom_forge_raw(forge, &c, 1);
-      }
-      lv2_atom_forge_pad(forge, len / 2);
-    } else {
-      lv2_atom_forge_literal(
-        forge, str, len, sratom->map->map(sratom->map->handle, type_uri), 0);
-    }
-  } else if (language) {
-    static const char* const prefix       = "http://lexvo.org/id/iso639-3/";
-    const size_t             prefix_len   = strlen(prefix);
-    const size_t             language_len = strlen(language);
-    const size_t             lang_uri_len = prefix_len + language_len;
-    char*                    lang_uri     = (char*)calloc(lang_uri_len + 1, 1);
-
-    memcpy(lang_uri, prefix, prefix_len + 1);
-    memcpy(lang_uri + prefix_len, language, language_len + 1);
-
-    lv2_atom_forge_literal(
-      forge, str, len, 0, sratom->map->map(sratom->map->handle, lang_uri));
-    free(lang_uri);
-  } else {
-    lv2_atom_forge_string(forge, str, len);
-  }
-}
-
-static void
-read_object(Sratom*         sratom,
-            LV2_Atom_Forge* forge,
-            SordWorld*      world,
-            SordModel*      model,
-            const SordNode* node,
-            ReadMode        mode)
-{
-  LV2_URID_Map* map = sratom->map;
-  size_t        len = 0;
-  const char*   str = (const char*)sord_node_get_string_counted(node, &len);
-
-  SordNode* type  = sord_get(model, node, sratom->nodes.rdf_type, NULL, NULL);
-  SordNode* value = sord_get(model, node, sratom->nodes.rdf_value, NULL, NULL);
-
-  const uint8_t* type_uri  = NULL;
-  uint32_t       type_urid = 0;
-  if (type) {
-    type_uri  = sord_node_get_string(type);
-    type_urid = map->map(map->handle, (const char*)type_uri);
-  }
-
-  LV2_Atom_Forge_Frame frame = {0, 0};
-  if (mode == MODE_SEQUENCE) {
-    SordNode* time =
-      sord_get(model, node, sratom->nodes.atom_beatTime, NULL, NULL);
-    uint32_t seq_unit = 0u;
-    if (time) {
-      const char* time_str = (const char*)sord_node_get_string(time);
-      lv2_atom_forge_beat_time(forge, serd_strtod(time_str, NULL));
-      seq_unit = sratom->atom_beatTime;
-    } else {
-      time = sord_get(model, node, sratom->nodes.atom_frameTime, NULL, NULL);
-      const char* time_str =
-        time ? (const char*)sord_node_get_string(time) : "";
-      lv2_atom_forge_frame_time(forge, serd_strtod(time_str, NULL));
-      seq_unit = sratom->atom_frameTime;
-    }
-    read_node(sratom, forge, world, model, value, MODE_BODY);
-    sord_node_free(world, time);
-    sratom->seq_unit = seq_unit;
-  } else if (type_urid == sratom->forge.Tuple) {
-    lv2_atom_forge_tuple(forge, &frame);
-    read_list_value(sratom, forge, world, model, value, MODE_BODY);
-  } else if (type_urid == sratom->forge.Sequence) {
-    const LV2_Atom_Forge_Ref ref =
-      lv2_atom_forge_sequence_head(forge, &frame, 0);
-    sratom->seq_unit = 0;
-    read_list_value(sratom, forge, world, model, value, MODE_SEQUENCE);
-
-    LV2_Atom_Sequence* seq =
-      (LV2_Atom_Sequence*)lv2_atom_forge_deref(forge, ref);
-    seq->body.unit =
-      (sratom->seq_unit == sratom->atom_frameTime) ? 0 : sratom->seq_unit;
-  } else if (type_urid == sratom->forge.Vector) {
-    SordNode* child_type_node =
-      sord_get(model, node, sratom->nodes.atom_childType, NULL, NULL);
-    uint32_t child_type =
-      map->map(map->handle, (const char*)sord_node_get_string(child_type_node));
-    uint32_t child_size = atom_size(sratom, child_type);
-    if (child_size > 0) {
-      LV2_Atom_Forge_Ref ref =
-        lv2_atom_forge_vector_head(forge, &frame, child_size, child_type);
-      read_list_value(sratom, forge, world, model, value, MODE_BODY);
-      lv2_atom_forge_pop(forge, &frame);
-      frame.ref = 0;
-      lv2_atom_forge_pad(forge, lv2_atom_forge_deref(forge, ref)->size);
-    }
-    sord_node_free(world, child_type_node);
-  } else if (value && sord_node_equals(sord_node_get_datatype(value),
-                                       sratom->nodes.xsd_base64Binary)) {
-    size_t         vlen = 0;
-    const uint8_t* vstr = sord_node_get_string_counted(value, &vlen);
-    size_t         size = 0;
-    void*          body = serd_base64_decode(vstr, vlen, &size);
-    lv2_atom_forge_atom(forge, size, type_urid);
-    lv2_atom_forge_write(forge, body, size);
-    free(body);
-  } else if (sord_node_get_type(node) == SORD_URI) {
-    lv2_atom_forge_object(forge, &frame, map->map(map->handle, str), type_urid);
-    read_resource(sratom, forge, world, model, node, type_urid);
-  } else {
-    lv2_atom_forge_object(forge, &frame, 0, type_urid);
-    read_resource(sratom, forge, world, model, node, type_urid);
-  }
-
-  if (frame.ref) {
-    lv2_atom_forge_pop(forge, &frame);
-  }
-  sord_node_free(world, value);
-  sord_node_free(world, type);
-}
-
-static void
-read_node(Sratom*         sratom,
-          LV2_Atom_Forge* forge,
-          SordWorld*      world,
-          SordModel*      model,
-          const SordNode* node,
-          ReadMode        mode)
-{
-  LV2_URID_Map* map = sratom->map;
-  size_t        len = 0;
-  const char*   str = (const char*)sord_node_get_string_counted(node, &len);
-  if (sord_node_get_type(node) == SORD_LITERAL) {
-    read_literal(sratom, forge, node);
-  } else if (sord_node_get_type(node) == SORD_URI &&
-             !(sratom->object_mode == SRATOM_OBJECT_MODE_BLANK_SUBJECT &&
-               mode == MODE_SUBJECT)) {
-    if (!strcmp(str, (const char*)NS_RDF "nil")) {
-      lv2_atom_forge_atom(forge, 0, 0);
-    } else if (!strncmp(str, "file://", 7)) {
-      SerdURI uri;
-      serd_uri_parse((const uint8_t*)str, &uri);
-
-      SerdNode rel =
-        serd_node_new_relative_uri(&uri, &sratom->base, NULL, NULL);
-      uint8_t* path = serd_file_uri_parse(rel.buf, NULL);
-      if (path) {
-        lv2_atom_forge_path(
-          forge, (const char*)path, strlen((const char*)path));
-        serd_free(path);
-      } else {
-        // FIXME: Report errors (required API change)
-        lv2_atom_forge_atom(forge, 0, 0);
-      }
-      serd_node_free(&rel);
-    } else {
-      lv2_atom_forge_urid(forge, map->map(map->handle, str));
-    }
-  } else {
-    read_object(sratom, forge, world, model, node, mode);
-  }
-}
-
-void
-sratom_read(Sratom*         sratom,
-            LV2_Atom_Forge* forge,
-            SordWorld*      world,
-            SordModel*      model,
-            const SordNode* node)
-{
-  sratom->nodes.atom_childType = sord_new_uri(world, USTR(LV2_ATOM__childType));
-  sratom->nodes.atom_frameTime = sord_new_uri(world, USTR(LV2_ATOM__frameTime));
-  sratom->nodes.atom_beatTime  = sord_new_uri(world, USTR(LV2_ATOM__beatTime));
-  sratom->nodes.rdf_first      = sord_new_uri(world, NS_RDF "first");
-  sratom->nodes.rdf_rest       = sord_new_uri(world, NS_RDF "rest");
-  sratom->nodes.rdf_type       = sord_new_uri(world, NS_RDF "type");
-  sratom->nodes.rdf_value      = sord_new_uri(world, NS_RDF "value");
-  sratom->nodes.xsd_base64Binary = sord_new_uri(world, NS_XSD "base64Binary");
-
-  sratom->next_id = 1;
-  read_node(sratom, forge, world, model, node, MODE_SUBJECT);
-
-  sord_node_free(world, sratom->nodes.xsd_base64Binary);
-  sord_node_free(world, sratom->nodes.rdf_value);
-  sord_node_free(world, sratom->nodes.rdf_type);
-  sord_node_free(world, sratom->nodes.rdf_rest);
-  sord_node_free(world, sratom->nodes.rdf_first);
-  sord_node_free(world, sratom->nodes.atom_frameTime);
-  sord_node_free(world, sratom->nodes.atom_beatTime);
-  sord_node_free(world, sratom->nodes.atom_childType);
-  memset(&sratom->nodes, 0, sizeof(sratom->nodes));
-}
-
-LV2_Atom_Forge_Ref
-sratom_forge_sink(LV2_Atom_Forge_Sink_Handle handle,
-                  const void*                buf,
-                  uint32_t                   size)
-{
-  SerdChunk*               chunk = (SerdChunk*)handle;
-  const LV2_Atom_Forge_Ref ref   = chunk->len + 1;
-  serd_chunk_sink(buf, size, chunk);
-  return ref;
-}
-
-LV2_Atom*
-sratom_forge_deref(LV2_Atom_Forge_Sink_Handle handle, LV2_Atom_Forge_Ref ref)
-{
-  SerdChunk* chunk = (SerdChunk*)handle;
-  return (LV2_Atom*)(chunk->buf + ref - 1);
-}
-
-LV2_Atom*
-sratom_from_turtle(Sratom*         sratom,
-                   const char*     base_uri,
-                   const SerdNode* subject,
-                   const SerdNode* predicate,
-                   const char*     str)
-{
-  SerdChunk out = {NULL, 0};
-  SerdNode  base =
-    serd_node_new_uri_from_string(USTR(base_uri), &sratom->base, NULL);
-  SordWorld*  world  = sord_world_new();
-  SordModel*  model  = sord_new(world, SORD_SPO, false);
-  SerdEnv*    env    = sratom->env ? sratom->env : serd_env_new(&base);
-  SerdReader* reader = sord_new_reader(model, env, SERD_TURTLE, NULL);
-
-  if (!serd_reader_read_string(reader, (const uint8_t*)str)) {
-    SordNode* s = sord_node_from_serd_node(world, env, subject, 0, 0);
-    lv2_atom_forge_set_sink(
-      &sratom->forge, sratom_forge_sink, sratom_forge_deref, &out);
-    if (subject && predicate) {
-      SordNode* p = sord_node_from_serd_node(world, env, predicate, 0, 0);
-      SordNode* o = sord_get(model, s, p, NULL, NULL);
-      if (o) {
-        sratom_read(sratom, &sratom->forge, world, model, o);
-        sord_node_free(world, o);
-      } else {
-        fprintf(stderr, "Failed to find node\n");
-      }
-    } else {
-      sratom_read(sratom, &sratom->forge, world, model, s);
-    }
-  } else {
-    fprintf(stderr, "Failed to read Turtle\n");
-  }
-
-  serd_reader_free(reader);
-  if (!sratom->env) {
-    serd_env_free(env);
-  }
-
-  sord_free(model);
-  sord_world_free(world);
-  serd_node_free(&base);
-
-  return (LV2_Atom*)out.buf;
-}